Adding upstream version 2.0.16.upstream/2.0.16upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 1039 insertions, 0 deletions

diff --git a/src/raptor_term.c b/src/raptor_term.c
new file mode 100644
index 0000000..d6fa52b
--- /dev/null
+++ b/src/raptor_term.c
@@ -0,0 +1,1039 @@
+/* -*- Mode: c; c-basic-offset: 2 -*-
+ *
+ * raptor_term.c - Raptor terms
+ *
+ * Copyright (C) 2010, David Beckett http://www.dajobe.org/
+ * 
+ * This package is Free Software and part of Redland http://librdf.org/
+ * 
+ * It is licensed under the following three licenses as alternatives:
+ *   1. GNU Lesser General Public License (LGPL) V2.1 or any newer version
+ *   2. GNU General Public License (GPL) V2 or any newer version
+ *   3. Apache License, V2.0 or any newer version
+ * 
+ * You may not use this file except in compliance with at least one of
+ * the above three licenses.
+ * 
+ * See LICENSE.html or LICENSE.txt at the top of this package for the
+ * complete terms and further detail along with the license texts for
+ * the licenses in COPYING.LIB, COPYING and LICENSE-2.0.txt respectively.
+ * 
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <raptor_config.h>
+#endif
+
+#include <stdio.h>
+#include <string.h>
+#include <ctype.h>
+#include <stdarg.h>
+#ifdef HAVE_STDLIB_H
+#include <stdlib.h>
+#endif
+
+/* Raptor includes */
+#include "raptor2.h"
+#include "raptor_internal.h"
+
+
+#ifndef STANDALONE
+
+/**
+ * raptor_new_term_from_uri:
+ * @world: raptor world
+ * @uri: uri
+ *
+ * Constructor - create a new URI statement term
+ *
+ * Takes a copy (reference) of the passed in @uri
+ *
+ * Return value: new term or NULL on failure
+*/
+raptor_term*
+raptor_new_term_from_uri(raptor_world* world, raptor_uri* uri)
+{
+  raptor_term *t;
+
+  RAPTOR_CHECK_CONSTRUCTOR_WORLD(world);
+
+  if(!uri)
+    return NULL;
+  
+  raptor_world_open(world);
+
+  t = RAPTOR_CALLOC(raptor_term*, 1, sizeof(*t));
+  if(!t)
+    return NULL;
+
+  t->usage = 1;
+  t->world = world;
+  t->type = RAPTOR_TERM_TYPE_URI;
+  t->value.uri = raptor_uri_copy(uri);
+
+  return t;
+}
+
+
+/**
+ * raptor_new_term_from_counted_uri_string:
+ * @world: raptor world
+ * @uri_string: UTF-8 encoded URI string.
+ * @length: length of URI string
+ *
+ * Constructor - create a new URI statement term from a UTF-8 encoded Unicode string
+ *
+ * Note: The @uri_string need not be NULL terminated - a NULL will be
+ * added to the copied string used.
+ *
+ * Return value: new term or NULL on failure
+*/
+raptor_term*
+raptor_new_term_from_counted_uri_string(raptor_world* world, 
+                                        const unsigned char *uri_string,
+                                        size_t length)
+{
+  raptor_term *t;
+  raptor_uri* uri;
+
+  RAPTOR_CHECK_CONSTRUCTOR_WORLD(world);
+
+  uri = raptor_new_uri_from_counted_string(world, uri_string, length);
+  if(!uri)
+    return NULL;
+
+  t = raptor_new_term_from_uri(world, uri);
+  
+  raptor_free_uri(uri);
+  
+  return t;
+}
+
+
+/**
+ * raptor_new_term_from_uri_string:
+ * @world: raptor world
+ * @uri_string: UTF-8 encoded URI string.
+ *
+ * Constructor - create a new URI statement term from a UTF-8 encoded Unicode string
+ *
+ * Return value: new term or NULL on failure
+*/
+raptor_term*
+raptor_new_term_from_uri_string(raptor_world* world, 
+                                const unsigned char *uri_string)
+{
+  raptor_term *t;
+  raptor_uri* uri;
+
+  RAPTOR_CHECK_CONSTRUCTOR_WORLD(world);
+
+  uri = raptor_new_uri(world, uri_string);
+  if(!uri)
+    return NULL;
+
+  t = raptor_new_term_from_uri(world, uri);
+  
+  raptor_free_uri(uri);
+  
+  return t;
+}
+
+
+/**
+ * raptor_new_term_from_counted_literal:
+ * @world: raptor world
+ * @literal: UTF-8 encoded literal string (or NULL for empty literal)
+ * @literal_len: length of literal
+ * @datatype: literal datatype URI (or NULL)
+ * @language: literal language (or NULL for no language)
+ * @language_len: literal language length
+ *
+ * Constructor - create a new literal statement term from a counted UTF-8 encoded literal string
+ *
+ * Takes copies of the passed in @literal, @datatype, @language
+ *
+ * Only one of @language or @datatype may be given.  If both are
+ * given, NULL is returned.  If @language is the empty string, it is
+ * the equivalent to NULL.
+ *
+ * Note: The @literal need not be NULL terminated - a NULL will be
+ * added to the copied string used.
+ *
+ * Return value: new term or NULL on failure
+ */
+raptor_term*
+raptor_new_term_from_counted_literal(raptor_world* world,
+                                     const unsigned char* literal,
+                                     size_t literal_len,
+                                     raptor_uri* datatype,
+                                     const unsigned char* language,
+                                     unsigned char language_len)
+{
+  raptor_term *t;
+  unsigned char* new_literal = NULL;
+  unsigned char* new_language = NULL;
+
+  RAPTOR_CHECK_CONSTRUCTOR_WORLD(world);
+
+  raptor_world_open(world);
+
+  if(language && !*language)
+    language = NULL;
+
+  if(language && datatype)
+    return NULL;
+  
+
+  new_literal = RAPTOR_MALLOC(unsigned char*, literal_len + 1);
+  if(!new_literal)
+    return NULL;
+
+  if(!literal || !*literal)
+    literal_len = 0;
+
+  if(literal_len) {
+    memcpy(new_literal, literal, literal_len);
+    new_literal[literal_len] = '\0';
+  } else
+    *new_literal = '\0';
+
+  if(language) {
+    unsigned char c;
+    unsigned char* l;
+    
+    new_language = RAPTOR_MALLOC(unsigned char*, language_len + 1);
+    if(!new_language) {
+      RAPTOR_FREE(char*, new_literal);
+      return NULL;
+    }
+
+    l = new_language;
+    while((c = *language++)) {
+      if(c == '_')
+        c = '-';
+      *l++ = c;
+    }
+    *l = '\0';
+  } else
+    language_len = 0;
+
+  if(datatype)
+    datatype = raptor_uri_copy(datatype);
+  
+
+  t = RAPTOR_CALLOC(raptor_term*, 1, sizeof(*t));
+  if(!t) {
+    if(new_literal)
+      RAPTOR_FREE(char*, new_literal);
+    if(new_language)
+      RAPTOR_FREE(char*, new_language);
+    if(datatype)
+      raptor_free_uri(datatype);
+    return NULL;
+  }
+  t->usage = 1;
+  t->world = world;
+  t->type = RAPTOR_TERM_TYPE_LITERAL;
+  t->value.literal.string = new_literal;
+  t->value.literal.string_len = RAPTOR_LANG_LEN_FROM_INT(literal_len);
+  t->value.literal.language = new_language;
+  t->value.literal.language_len = language_len;
+  t->value.literal.datatype = datatype;
+
+  return t;
+}
+
+
+/**
+ * raptor_new_term_from_literal:
+ * @world: raptor world
+ * @literal: UTF-8 encoded literal string (or NULL for empty literal)
+ * @datatype: literal datatype URI (or NULL)
+ * @language: literal language (or NULL)
+ *
+ * Constructor - create a new literal statement term
+ *
+ * Takes copies of the passed in @literal, @datatype, @language
+ *
+ * Only one of @language or @datatype may be given.  If both are
+ * given, NULL is returned.  If @language is the empty string, it is
+ * the equivalent to NULL.
+ *
+ * Return value: new term or NULL on failure
+*/
+raptor_term*
+raptor_new_term_from_literal(raptor_world* world,
+                             const unsigned char* literal,
+                             raptor_uri* datatype,
+                             const unsigned char* language)
+{
+  size_t literal_len = 0;
+  size_t language_len = 0;
+  
+  RAPTOR_CHECK_CONSTRUCTOR_WORLD(world);
+
+  raptor_world_open(world);
+
+  if(literal)
+    literal_len = strlen(RAPTOR_GOOD_CAST(const char*, literal));
+
+  if(language)
+    language_len = strlen(RAPTOR_GOOD_CAST(const char*, language));
+
+  return raptor_new_term_from_counted_literal(world, literal, literal_len,
+                                              datatype, language,
+                                              RAPTOR_BAD_CAST(unsigned char, language_len));
+}
+
+
+/**
+ * raptor_new_term_from_counted_blank:
+ * @world: raptor world
+ * @blank: UTF-8 encoded blank node identifier (or NULL)
+ * @length: length of identifier (or 0)
+ *
+ * Constructor - create a new blank node statement term from a counted UTF-8 encoded blank node ID
+ *
+ * Takes a copy of the passed in @blank
+ *
+ * If @blank is NULL, creates a new internal identifier and uses it.
+ * This will use the handler set with
+ * raptor_world_set_generate_bnodeid_parameters()
+ *
+ * Note: The @blank need not be NULL terminated - a NULL will be
+ * added to the copied string used.
+ *
+ * Return value: new term or NULL on failure
+*/
+raptor_term*
+raptor_new_term_from_counted_blank(raptor_world* world,
+                                   const unsigned char* blank, size_t length)
+{
+  raptor_term *t;
+  unsigned char* new_id;
+
+  RAPTOR_CHECK_CONSTRUCTOR_WORLD(world);
+
+  raptor_world_open(world);
+
+  if (blank) {
+    new_id = RAPTOR_MALLOC(unsigned char*, length + 1);
+    if(!new_id)
+      return NULL;
+    memcpy(new_id, blank, length);
+    new_id[length] = '\0';
+  } else {
+    new_id = raptor_world_generate_bnodeid(world);
+    length = strlen((const char*)new_id);
+  }
+
+  t = RAPTOR_CALLOC(raptor_term*, 1, sizeof(*t));
+  if(!t) {
+    RAPTOR_FREE(char*, new_id);
+    return NULL;
+  }
+
+  t->usage = 1;
+  t->world = world;
+  t->type = RAPTOR_TERM_TYPE_BLANK;
+  t->value.blank.string = new_id;
+  t->value.blank.string_len = RAPTOR_BAD_CAST(int, length);
+
+  return t;
+}
+
+
+/**
+ * raptor_new_term_from_blank:
+ * @world: raptor world
+ * @blank: UTF-8 encoded blank node identifier (or NULL)
+ *
+ * Constructor - create a new blank node statement term from a UTF-8 encoded blank node ID
+ *
+ * Takes a copy of the passed in @blank
+ *
+ * If @blank is NULL or an empty string, creates a new internal
+ * identifier and uses it.  This will use the handler set with
+ * raptor_world_set_generate_bnodeid_parameters()
+ *
+ * Return value: new term or NULL on failure
+*/
+raptor_term*
+raptor_new_term_from_blank(raptor_world* world, const unsigned char* blank)
+{
+  size_t length = 0;
+  
+  RAPTOR_CHECK_CONSTRUCTOR_WORLD(world);
+
+  raptor_world_open(world);
+
+  if(blank) {
+    if(*blank)
+      length = strlen((const char*)blank);
+    else
+      blank = NULL;
+  }
+
+  return raptor_new_term_from_counted_blank(world, blank, length);
+}
+
+
+/**
+ * raptor_new_term_from_counted_string:
+ * @world: raptor world
+ * @string: N-Triples format string (UTF-8)
+ * @length: length of @string (or 0)
+ *
+ * Constructor - create a new term from a Turtle / N-Triples format string in UTF-8
+ *
+ * See also raptor_term_to_counted_string() and raptor_term_to_string()
+ *
+ * Return value: new term or NULL on failure
+*/
+raptor_term*
+raptor_new_term_from_counted_string(raptor_world* world,
+                                    unsigned char* string, size_t length)
+{
+  raptor_term* term = NULL;
+  size_t bytes_read;
+  raptor_locator locator;
+
+  RAPTOR_CHECK_CONSTRUCTOR_WORLD(world);
+
+  if(!string)
+    return NULL;
+
+  if(!length)
+    length = strlen(RAPTOR_GOOD_CAST(const char*, string));
+
+  raptor_world_open(world);
+
+  memset(&locator, '\0', sizeof(locator));
+  locator.line = -1;
+
+  bytes_read = raptor_ntriples_parse_term(world, &locator,
+                                          string, &length, &term, 1);
+
+  if(!bytes_read || length != 0) {
+    if(term)
+      raptor_free_term(term);
+    term = NULL;
+  }
+
+  return term;
+}
+
+
+/**
+ * raptor_term_copy:
+ * @term: raptor term
+ *
+ * Copy constructor - get a copy of a statement term
+ *
+ * Return value: new term object or NULL on failure
+ */
+raptor_term*
+raptor_term_copy(raptor_term* term)
+{
+  if(!term)
+    return NULL;
+
+  term->usage++;
+  return term;
+}
+
+
+/**
+ * raptor_free_term:
+ * @term: #raptor_term object
+ *
+ * Destructor - destroy a raptor_term object.
+ *
+ **/
+void
+raptor_free_term(raptor_term *term)
+{
+  if(!term)
+    return;
+  
+  if(--term->usage)
+    return;
+  
+  switch(term->type) {
+    case RAPTOR_TERM_TYPE_URI:
+      if(term->value.uri) {
+        raptor_free_uri(term->value.uri);
+        term->value.uri = NULL;
+      }
+      break;
+
+    case RAPTOR_TERM_TYPE_BLANK:
+      if(term->value.blank.string) {
+        RAPTOR_FREE(char*, term->value.blank.string);
+        term->value.blank.string = NULL;
+      }
+      break;
+      
+    case RAPTOR_TERM_TYPE_LITERAL:
+      if(term->value.literal.string) {
+        RAPTOR_FREE(char*, term->value.literal.string);
+        term->value.literal.string = NULL;
+      }
+
+      if(term->value.literal.datatype) {
+        raptor_free_uri(term->value.literal.datatype);
+        term->value.literal.datatype = NULL;
+      }
+      
+      if(term->value.literal.language) {
+        RAPTOR_FREE(char*, term->value.literal.language);
+        term->value.literal.language = NULL;
+      }
+      break;
+      
+    case RAPTOR_TERM_TYPE_UNKNOWN:
+    default:
+      break;
+  }
+
+  RAPTOR_FREE(term, term);
+}
+
+
+/**
+ * raptor_term_to_counted_string:
+ * @term: #raptor_term
+ * @len_p: Pointer to location to store length of new string (if not NULL)
+ *
+ * Turns a raptor term into a N-Triples format counted string.
+ * 
+ * Turns the given @term into an N-Triples escaped string using all the
+ * escapes as defined in http://www.w3.org/TR/rdf-testcases/#ntriples
+ *
+ * This function uses raptor_term_ntriples_write() to write to an
+ * #raptor_iostream which is the prefered way to write formatted
+ * output.
+ *
+ * See also raptor_new_term_from_counted_string() to reverse this.
+ *
+ * See also raptor_term_to_turtle_string() to write as Turtle which
+ * will include Turtle syntax such as 'true' for booleans and """quoting"""
+ *
+ * Return value: the new string or NULL on failure.  The length of
+ * the new string is returned in *@len_p if len_p is not NULL.
+ **/
+unsigned char*
+raptor_term_to_counted_string(raptor_term *term, size_t* len_p)
+{
+  raptor_iostream *iostr;
+  void *string = NULL;
+  int rc;
+
+  RAPTOR_ASSERT_OBJECT_POINTER_RETURN_VALUE(term, raptor_term, NULL);
+  
+  iostr = raptor_new_iostream_to_string(term->world, 
+                                        &string, len_p, NULL);
+  if(!iostr)
+    return NULL;
+
+  rc = raptor_term_escaped_write(term, 0, iostr);
+  raptor_free_iostream(iostr);
+  
+  if(rc) {
+    if(string) {
+      RAPTOR_FREE(char*, string);
+      string = NULL;
+    }
+  }
+
+  return (unsigned char *)string;
+}
+
+
+/**
+ * raptor_term_to_string:
+ * @term: #raptor_term
+ *
+ * Turns a raptor term into a N-Triples format string.
+ * 
+ * Turns the given @term into an N-Triples escaped string using all the
+ * escapes as defined in http://www.w3.org/TR/rdf-testcases/#ntriples
+ *
+ * See also raptor_new_term_from_counted_string() to reverse this.
+ *
+ * See also raptor_term_to_turtle_string() to write as Turtle which
+ * will include Turtle syntax such as 'true' for booleans and """quoting"""
+ *
+ * Return value: the new string or NULL on failure.
+ **/
+unsigned char*
+raptor_term_to_string(raptor_term *term)
+{
+  RAPTOR_ASSERT_OBJECT_POINTER_RETURN_VALUE(term, raptor_term, NULL);
+  
+  return raptor_term_to_counted_string(term, NULL);
+}
+
+
+/*
+ * raptor_term_print_as_ntriples:
+ * @term: #raptor_term
+ * @stream: FILE stream
+ *
+ * INTERNAL - Print a term as N-Triples
+ */
+int
+raptor_term_print_as_ntriples(const raptor_term *term, FILE* stream)
+{
+  int rc = 0;
+  raptor_iostream* iostr;
+
+  RAPTOR_ASSERT_OBJECT_POINTER_RETURN_VALUE(term, raptor_term, 1);
+  RAPTOR_ASSERT_OBJECT_POINTER_RETURN_VALUE(stream, FILE*, 1);
+  
+  iostr = raptor_new_iostream_to_file_handle(term->world, stream);
+  if(!iostr)
+    return 1;
+  
+  rc = raptor_term_escaped_write(term, 0, iostr);
+
+  raptor_free_iostream(iostr);
+  
+  return rc;
+}
+
+
+/**
+ * raptor_term_equals:
+ * @t1: first term
+ * @t2: second term
+ *
+ * Compare a pair of #raptor_term for equality
+ *
+ * Return value: non-0 if the terms are equal
+ */
+int
+raptor_term_equals(raptor_term* t1, raptor_term* t2)
+{
+  int d = 0;
+
+  if(!t1 || !t2)
+    return 0;
+  
+  if(t1->type != t2->type)
+    return 0;
+  
+  if(t1 == t2)
+    return 1;
+  
+  switch(t1->type) {
+    case RAPTOR_TERM_TYPE_URI:
+      d = raptor_uri_equals(t1->value.uri, t2->value.uri);
+      break;
+
+    case RAPTOR_TERM_TYPE_BLANK:
+      if(t1->value.blank.string_len != t2->value.blank.string_len)
+        /* different lengths */
+        break;
+
+      d = !strcmp((const char*)t1->value.blank.string, 
+                  (const char*)t2->value.blank.string);
+      break;
+
+    case RAPTOR_TERM_TYPE_LITERAL:
+      if(t1->value.literal.string_len != t2->value.literal.string_len)
+        /* different lengths */
+        break;
+
+      d = !strcmp((const char*)t1->value.literal.string,
+                  (const char*)t2->value.literal.string);
+      if(!d)
+        break;
+      
+      if(t1->value.literal.language && t2->value.literal.language) {
+        /* both have a language */
+        d = !strcmp((const char*)t1->value.literal.language, 
+                    (const char*)t2->value.literal.language);
+        if(!d)
+          break;
+      } else if(t1->value.literal.language || t2->value.literal.language) {
+        /* only one has a language - different */
+        d = 0;
+        break;
+      }
+
+      if(t1->value.literal.datatype && t2->value.literal.datatype) {
+        /* both have a datatype */
+        d = raptor_uri_equals(t1->value.literal.datatype,
+                              t2->value.literal.datatype);
+      } else if(t1->value.literal.datatype || t2->value.literal.datatype) {
+        /* only one has a datatype - different */
+        d = 0;
+      }
+      break;
+      
+    case RAPTOR_TERM_TYPE_UNKNOWN:
+    default:
+      break;
+  }
+
+  return d;
+}
+
+
+/**
+ * raptor_term_compare:
+ * @t1: first term
+ * @t2: second term
+ *
+ * Compare a pair of #raptor_term
+ *
+ * If types are different, the #raptor_term_type order is used.
+ *
+ * Resource and datatype URIs are compared with raptor_uri_compare(),
+ * blank nodes and literals with strcmp().  If one literal has no
+ * language, it is earlier than one with a language.  If one literal
+ * has no datatype, it is earlier than one with a datatype.
+ * 
+ * Return value: <0 if t1 is before t2, 0 if equal, >0 if t1 is after t2
+ */
+int
+raptor_term_compare(const raptor_term *t1,  const raptor_term *t2)
+{
+  int d = 0;
+  
+  /* check for NULL terms */
+  if(!t1 || !t2) {
+    if(!t1 && !t2)
+      return 0; /* both NULL */
+
+    /* place NULLs before any other term */
+    return t1 ? 1 : -1;
+  }
+
+  if(t1->type != t2->type)
+    return (t1->type - t2->type);
+  
+  switch(t1->type) {
+    case RAPTOR_TERM_TYPE_URI:
+      d = raptor_uri_compare(t1->value.uri, t2->value.uri);
+      break;
+
+    case RAPTOR_TERM_TYPE_BLANK:
+      d = strcmp((const char*)t1->value.blank.string,
+                 (const char*)t2->value.blank.string);
+      break;
+      
+    case RAPTOR_TERM_TYPE_LITERAL:
+      d = strcmp((const char*)t1->value.literal.string,
+                 (const char*)t2->value.literal.string);
+      if(d)
+        break;
+      
+      if(t1->value.literal.language && t2->value.literal.language) {
+        /* both have a language */
+        d = strcmp((const char*)t1->value.literal.language, 
+                   (const char*)t2->value.literal.language);
+      } else if(t1->value.literal.language || t2->value.literal.language)
+        /* only one has a language; the language-less one is earlier */
+        d = (!t1->value.literal.language ? -1 : 1);
+      if(d)
+        break;
+      
+      if(t1->value.literal.datatype && t2->value.literal.datatype) {
+        /* both have a datatype */
+        d = raptor_uri_compare(t1->value.literal.datatype,
+                               t2->value.literal.datatype);
+      } else if(t1->value.literal.datatype || t2->value.literal.datatype)
+        /* only one has a datatype; the datatype-less one is earlier */
+        d = (!t1->value.literal.datatype ? -1 : 1);
+      break;
+      
+    case RAPTOR_TERM_TYPE_UNKNOWN:
+    default:
+      break;
+  }
+
+  return d;
+}
+#endif
+
+
+
+#ifdef STANDALONE
+
+/* one more prototype */
+int main(int argc, char *argv[]);
+
+static const unsigned char *uri_string1 = (const unsigned char *)"http://http://www.dajobe.org/";
+static unsigned int uri_string1_len = 29; /* strlen(uri_string1) */
+static raptor_term_type uri_string1_type = RAPTOR_TERM_TYPE_URI;
+static const unsigned char *uri_string2 = (const unsigned char *)"http://www.example.org/";
+static unsigned int uri_string2_len = 23; /* strlen(uri_string2) */
+static raptor_term_type uri_string2_type = RAPTOR_TERM_TYPE_URI;
+static const unsigned char *literal_string1 = (const unsigned char *)"Dave Beckett";
+static unsigned int literal_string1_len = 12; /* strlen(literal_string1) */
+static raptor_term_type literal_string1_type = RAPTOR_TERM_TYPE_LITERAL;
+static const unsigned char *bnodeid1 = (const unsigned char *)"abc123";
+static unsigned int bnodeid1_len = 6; /* strlen(bnode_id1) */
+static raptor_term_type bnodeid1_type = RAPTOR_TERM_TYPE_BLANK;
+static const unsigned char* language1 = (const unsigned char*)"en";
+
+int
+main(int argc, char *argv[])
+{
+  raptor_world *world;
+  const char *program = raptor_basename(argv[0]);
+  int rc = 0;
+  raptor_term* term1 = NULL; /* URI string 1 */
+  raptor_term* term2 = NULL; /* literal string1 */
+  raptor_term* term3 = NULL; /* blank node 1 */
+  raptor_term* term4 = NULL; /* URI string 2 */
+  raptor_term* term5 = NULL; /* URI string 1 again */
+  raptor_uri* uri1;
+  unsigned char* uri_str;
+  size_t uri_len;
+  
+  
+  world = raptor_new_world();
+  if(!world || raptor_world_open(world))
+    exit(1);
+
+
+  /* check a term for NULL URI fails */
+  term1 = raptor_new_term_from_uri(world, NULL);
+  if(term1) {
+    fprintf(stderr, "%s: raptor_new_uri(NULL) returned object rather than failing\n", program);
+    rc = 1;
+    goto tidy;
+  }
+
+  /* check a term for non-NULL URI succeeds */
+  uri1 = raptor_new_uri(world, uri_string1);
+  if(!uri1) {
+    fprintf(stderr, "%s: raptor_new_uri(%s) failed\n", program, uri_string1);
+    rc = 1;
+    goto tidy;
+  }
+  term1 = raptor_new_term_from_uri(world, uri1);
+  if(!term1) {
+    fprintf(stderr, "%s: raptor_new_term_from_uri_string(URI %s) failed\n",
+            program, uri_string1);
+    rc = 1;
+    goto tidy;
+  }
+  raptor_free_uri(uri1); uri1 = NULL;
+  if(term1->type != uri_string1_type) {
+    fprintf(stderr, "%s: raptor term 1 is of type %d expected %d\n",
+            program, term1->type, uri_string1_type);
+    rc = 1;
+    goto tidy;
+  }
+
+
+  /* returns a pointer to shared string */
+  uri_str = raptor_uri_as_counted_string(term1->value.uri, &uri_len);
+  if(!uri_str) {
+    fprintf(stderr, "%s: raptor_uri_as_counted_string term 1 failed\n",
+            program);
+    rc = 1;
+    goto tidy;
+  }
+
+  if(uri_len != uri_string1_len) {
+    fprintf(stderr, "%s: raptor term 1 URI is of length %d expected %d\n",
+            program, (int)uri_len, (int)uri_string1_len);
+    rc = 1;
+    goto tidy;
+  }
+
+  
+  /* check an empty literal is created from a NULL literal pointer succeeds */
+  term2 = raptor_new_term_from_counted_literal(world, NULL, 0, NULL, NULL, 0);
+  if(!term2) {
+    fprintf(stderr, "%s: raptor_new_term_from_counted_literal() with all NULLs failed\n", program);
+    rc = 1;
+    goto tidy;
+  }
+  raptor_free_term(term2);
+
+
+  /* check an empty literal from an empty language literal pointer succeeds */
+  term2 = raptor_new_term_from_counted_literal(world, NULL, 0, NULL,
+                                               (const unsigned char*)"", 0);
+  if(!term2) {
+    fprintf(stderr, "%s: raptor_new_term_from_counted_literal() with empty language failed\n", program);
+    rc = 1;
+    goto tidy;
+  }
+  raptor_free_term(term2);
+
+  /* check a literal with language and datatype fails */
+  uri1 = raptor_new_uri(world, uri_string1);
+  if(!uri1) {
+    fprintf(stderr, "%s: raptor_new_uri(%s) failed\n", program, uri_string1);
+    rc = 1;
+    goto tidy;
+  }
+  term2 = raptor_new_term_from_counted_literal(world, literal_string1,
+                                               literal_string1_len, 
+                                               uri1, language1, 0);
+  raptor_free_uri(uri1); uri1 = NULL;
+  if(term2) {
+    fprintf(stderr, "%s: raptor_new_term_from_counted_literal() with language and datatype returned object rather than failing\n", program);
+    rc = 1;
+    goto tidy;
+  }
+  
+  /* check a literal with no language and no datatype succeeds */
+  term2 = raptor_new_term_from_counted_literal(world, literal_string1,
+                                               literal_string1_len, NULL, NULL, 0);
+  if(!term2) {
+    fprintf(stderr, "%s: raptor_new_term_from_counted_literal(%s) failed\n",
+            program, literal_string1);
+    rc = 1;
+    goto tidy;
+  }
+  if(term2->type != literal_string1_type) {
+    fprintf(stderr, "%s: raptor term 2 is of type %d expected %d\n",
+            program, term2->type, literal_string1_type);
+    rc = 1;
+    goto tidy;
+  }
+  
+
+  /* check a blank node term with NULL id generates a new identifier */
+  term3 = raptor_new_term_from_counted_blank(world, NULL, 0);
+  if(!term3) {
+    fprintf(stderr, "%s: raptor_new_term_from_counted_blank(NULL) failed\n",
+            program);
+    rc = 1;
+    goto tidy;
+  }
+  if(term3->type != bnodeid1_type) {
+    fprintf(stderr, "%s: raptor term 3 is of type %d expected %d\n",
+            program, term3->type, bnodeid1_type);
+    rc = 1;
+    goto tidy;
+  }
+  raptor_free_term(term3);
+
+  /* check a blank node term with an identifier succeeds */
+  term3 = raptor_new_term_from_counted_blank(world, bnodeid1, bnodeid1_len);
+  if(!term3) {
+    fprintf(stderr, "%s: raptor_new_term_from_counted_blank(%s) failed\n",
+            program, bnodeid1);
+    rc = 1;
+    goto tidy;
+  }
+  if(term3->type != bnodeid1_type) {
+    fprintf(stderr, "%s: raptor term 3 is of type %d expected %d\n",
+            program, term3->type, bnodeid1_type);
+    rc = 1;
+    goto tidy;
+  }
+
+
+  /* check a different URI term succeeds */
+  term4 = raptor_new_term_from_counted_uri_string(world, uri_string2,
+                                                  uri_string2_len);
+  if(!term4) {
+    fprintf(stderr,
+            "%s: raptor_new_term_from_counted_uri_string(URI %s) failed\n",
+            program, uri_string2);
+    rc = 1;
+    goto tidy;
+  }
+  if(term4->type != uri_string2_type) {
+    fprintf(stderr, "%s: raptor term 4 is of type %d expected %d\n",
+            program, term4->type, uri_string2_type);
+    rc = 1;
+    goto tidy;
+  }
+  /* returns a pointer to shared string */
+  uri_str = raptor_uri_as_counted_string(term4->value.uri, &uri_len);
+  if(!uri_str) {
+    fprintf(stderr, "%s: raptor_uri_as_counted_string term 4 failed\n",
+            program);
+    rc = 1;
+    goto tidy;
+  }
+
+  if(uri_len != uri_string2_len) {
+    fprintf(stderr, "%s: raptor term 4 URI is of length %d expected %d\n",
+            program, (int)uri_len, (int)uri_string2_len);
+    rc = 1;
+    goto tidy;
+  }
+
+
+  /* check the same URI term as term1 succeeds */
+  term5 = raptor_new_term_from_uri_string(world, uri_string1);
+  if(!term5) {
+    fprintf(stderr, "%s: raptor_new_term_from_uri_string(URI %s) failed\n",
+            program, uri_string1);
+    rc = 1;
+    goto tidy;
+  }
+
+
+  if(raptor_term_equals(term1, term2)) {
+    fprintf(stderr, "%s: raptor_term_equals (URI %s, literal %s) returned equal, expected not-equal\n",
+            program, uri_string1, literal_string1);
+    rc = 1;
+    goto tidy;
+  }
+
+  if(raptor_term_equals(term1, term3)) {
+    fprintf(stderr, "%s: raptor_term_equals (URI %s, bnode %s) returned equal, expected not-equal\n",
+            program, uri_string1, bnodeid1);
+    rc = 1;
+    goto tidy;
+  }
+  
+  if(raptor_term_equals(term1, term4)) {
+    fprintf(stderr, "%s: raptor_term_equals (URI %s, URI %s) returned equal, expected not-equal\n",
+            program, uri_string1, uri_string2);
+    rc = 1;
+    goto tidy;
+  }
+  
+  if(!raptor_term_equals(term1, term5)) {
+    fprintf(stderr, "%s: raptor_term_equals (URI %s, URI %s) returned not-equal, expected equal\n",
+            program, uri_string1, uri_string1);
+    rc = 1;
+    goto tidy;
+  }
+
+  if(term1->value.uri != term5->value.uri) {
+    fprintf(stderr, "%s: term1 and term5 URI objects returned not-equal pointers, expected equal\n",
+            program);
+    /* This is not necessarily a failure if the raptor_uri module has had
+     * the URI interning disabled with
+     *   raptor_world_set_flag(world, RAPTOR_WORLD_FLAG_URI_INTERNING, 0) 
+     * however this test suite does not do that, so it is a failure here.
+     */
+    rc = 1;
+    goto tidy;
+  }
+  
+
+  tidy:
+  if(term1)
+    raptor_free_term(term1);
+  if(term2)
+    raptor_free_term(term2);
+  if(term3)
+    raptor_free_term(term3);
+  if(term4)
+    raptor_free_term(term4);
+  if(term5)
+    raptor_free_term(term5);
+  
+  raptor_free_world(world);
+
+  return rc;
+}
+
+#endif /* STANDALONE */