=== modified file 'modules/node/node.module'
--- modules/node/node.module	2009-10-05 01:18:25 +0000
+++ modules/node/node.module	2009-10-05 14:11:22 +0000
@@ -710,6 +710,40 @@ function node_type_set_defaults($info = 
 }
 
 /**
+ * Define the default RDF mapping for the node entity type.
+ *
+ * These default mapping properties are used by rdf_save_mapping() to populate
+ * non-existing properties before they are saved to the database.
+ *
+ * @return
+ *   A list of default mapping properties for the node entity type.
+ */
+function node_rdf_mapping_defaults() {
+    return array(
+      'rdftype' => array('sioc:Item', 'foaf:Document'),
+      'title'   => array(
+        'property' => array('dc:title'),
+      ),
+      'created' => array(
+        'property' => array('dc:date', 'dc:created'),
+        'datatype' => 'xsd:dateTime',
+        'callback' => 'date_iso8601',
+      ),
+      'changed' => array(
+        'property' => array('dc:modified'),
+      ),
+      'body'    => array(
+        'property' => array('content:encoded'),
+      ),
+      'uid'     => array(
+        'property' => array('sioc:has_creator', 'foaf:maker'),
+      ),
+      'name'    => array(
+        'property' => array('foaf:name'),
+      ),
+    );
+}
+/**
  * Determine whether a node hook exists.
  *
  * @param $node

=== modified file 'modules/node/node.test'
--- modules/node/node.test	2009-10-02 14:39:43 +0000
+++ modules/node/node.test	2009-10-07 18:00:24 +0000
@@ -615,6 +615,68 @@ class NodeRSSContentTestCase extends Dru
   }
 }
 
+class NodeRDFaTestCase extends DrupalWebTestCase {
+  public static function getInfo() {
+    return array(
+      'name' => t('Node RDFa output'),
+      'description' => t('Ensure that RDFa is output on node pages.'),
+      'group' => t('RDF misc'),
+    );
+  }
+
+  function setUp() {
+    parent::setUp('rdf');
+  }
+
+  function testNodeRdfa() {
+    $node = $this->drupalCreateNode(array('type' => 'article', 'promote' => 1));
+    $node_resource = check_url(url('node/' . $node->nid, array('fragment' => 'this')));
+    $user_resource = check_url(url('user/' . $node->uid, array('fragment' => 'this')));
+
+    // Test node in full node mode.
+    $this->drupalGet('node/' . $node->nid);
+
+    $result = $this->xpath('//div[contains(@class, "node") and contains(@typeof, "sioc:Item")]');
+    $this->assertFalse(empty($result), t('Found a typeof attribute including sioc:Item'));
+    // $this->assertEqual($result[0]['about'], $node_resource, t('Found correct about attribute'));
+
+    $result = $this->xpath('//div[contains(@class, "node") and contains(@typeof, "foaf:Document")]');
+    $this->assertFalse(empty($result), t('Found a typeof attribute including foaf:Document'));
+
+    $result = $this->xpath('//meta[contains(@property, "dc:title")]');
+    $this->assertFalse(empty($result), t('Found a meta tag with property=dc:title'));
+
+    // $result = $this->xpath('//*[contains(@class, "submitted")]//*[contains(@property, "dc:created")]');
+    // $this->assertFalse(empty($result), t('Found a dc:created property'));
+    // $this->assertEqual($result[0]['datatype'], 'xsd:dateTime', t('Found datatype of xsd:dateTime'));
+    // $this->assertTrue(preg_match('/\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\+\d{2}:\d{2}/', $result[0]['content']), t('Found a content attribute in the correct format'));
+
+    // $result = $this->xpath('//div[contains(@typeof, "foaf:Document")]//*[contains(@class, "content") and contains(@property, "content:encoded") and contains(@property, "dc:description")]');
+    // $this->assertFalse(empty($result), t('Found content:encoded and dc:description properties'));
+
+    // $result = $this->xpath('//*[contains(@class, "submitted")]//*[contains(@rel, "sioc:has_creator") and contains(@rel, "dc:creator")]');
+    // $this->assertFalse(empty($result), t('Found sioc:has_creator and dc:creator'));
+    // $result = $this->xpath('//*[contains(@class, "submitted")]//*[contains(@rel, "dc:creator")]//*[contains(@property, "foaf:name") and contains(@typeof, "sioc:User")]');
+    // $this->assertFalse(empty($result), t('Found foaf:name and sioc:User'));
+    // $this->assertEqual($result[0]['about'], $user_resource, t('Found correct about attribute'));
+
+    // Test node in teaser mode.
+    $this->drupalGet('');
+
+    $result = $this->xpath('//div[contains(@class, "node") and contains(@typeof, "sioc:Item")]');
+    $this->assertFalse(empty($result), t('Found a typeof attribute including sioc:Item'));
+    // $this->assertEqual($result[0]['about'], $node_resource, t('Found correct about attribute'));
+
+    $result = $this->xpath('//div[contains(@class, "node") and contains(@typeof, "foaf:Document")]');
+    $this->assertFalse(empty($result), t('Found a typeof attribute including foaf:Document'));
+
+    $result = $this->xpath('//h2[contains(@property, "dc:title")]');
+    $this->assertFalse(empty($result), t('Found a h2 tag with property=dc:title'));
+
+  }
+
+}
+
 /**
  * Test case to verify basic node_access functionality.
  * @todo Cover hook_access in a separate test class.

=== modified file 'modules/node/node.tpl.php'
--- modules/node/node.tpl.php	2009-09-11 06:48:02 +0000
+++ modules/node/node.tpl.php	2009-10-04 01:02:35 +0000
@@ -83,8 +83,8 @@
       <?php if ($display_submitted): ?>
         <span class="submitted">
           <?php
-            print t('Submitted by !username on @datetime',
-              array('!username' => $name, '@datetime' => $date));
+            print t('Submitted by !username on !datetime',
+              array('!username' => $name, '!datetime' => $date));
           ?>
         </span>
       <?php endif; ?>

=== added directory 'modules/rdf'
=== added file 'modules/rdf/rdf.api.php'
--- modules/rdf/rdf.api.php	1970-01-01 00:00:00 +0000
+++ modules/rdf/rdf.api.php	2009-10-03 17:25:00 +0000
@@ -0,0 +1,47 @@
+<?php
+// $Id$
+
+/**
+ * @file
+ * Hooks provided by the RDF module.
+ */
+
+/**
+ * @addtogroup hooks
+ * @{
+ */
+
+/**
+ * Allow modules to define RDF mappings for bundles.
+ *
+ * Modules defining their own bundles can specify which RDF semantics should be
+ * used to annotate these bundles. These mappings are then used for the
+ * automatic RDFa output in the HTML code. 
+ * 
+ * @return
+ *   An associative array of mappings. Most keys will be bundle names, but 
+ *   mappings can also be defined for non-bundles. Each bundle mapping is an
+ *   array whose keys must correspond to existing field instances in the
+ *   bundle with an array of RDF properties as value. The 'rdftype' key is a
+ *   special case which is used to define the type of the instance, its
+ *   value shoud be an array of RDF classes. 
+ */
+function hook_rdf_mapping() {
+  return array(
+    'blog' => array(
+      'rdftype' => array('sioc:Post'),
+      'title'   => array('dc:title'),
+      'created' => array(
+        'property' => array('dc:date', 'dc:created'),
+        'datatype' => 'xsd:dateTime',
+        'callback' => 'date_iso8601',
+      ),
+      'name'    => array('foaf:name'),
+      'uid'     => array('sioc:has_creator', 'foaf:maker'),
+    )
+  );
+} 
+
+/**
+ * @} End of "addtogroup hooks".
+ */

=== added file 'modules/rdf/rdf.crud.inc'
--- modules/rdf/rdf.crud.inc	1970-01-01 00:00:00 +0000
+++ modules/rdf/rdf.crud.inc	2009-10-03 17:25:00 +0000
@@ -0,0 +1,87 @@
+<?php
+// $Id$
+
+/**
+ * @file
+ * RDF CRUD API, handling RDF mapping creation and deletion.
+ */
+
+/**
+ * Create an RDF mapping binded to a bundle and an entity type.
+ *
+ * @param $type
+ *   The entity type the mapping refers to.
+ * @param $bundle
+ *   The bundle the mapping refers to.
+ * @param $mapping
+ *   An associative array represeting an RDF mapping structure.
+ * @return array
+ *   The stored mapping.
+ */
+function rdf_create_mapping($type, $bundle, $mapping) {
+  $fields = array(
+    'type' => $type,
+    'bundle' => $bundle,
+    'mapping' => serialize($mapping)
+  );
+
+  db_insert('rdf_mapping')->fields($fields)->execute();
+
+  return $mapping;
+}
+
+/**
+ * Read an RDF mapping record directly from the database.
+ *
+ * @param $type
+ *   The entity type the mapping refers to.
+ * @param $bundle
+ *   The bundle the mapping refers to.
+ * @return array
+ *   An RDF mapping structure or FALSE if the mapping could not be found.
+ */
+function rdf_read_mapping($type, $bundle) {
+  $query = db_select('rdf_mapping')->fields(NULL, array('mapping'))
+    ->condition('type', $type)->condition('bundle', $bundle)->execute();
+
+  return unserialize($query->fetchField());
+}
+
+/**
+ * Update an RDF mapping binded to a bundle and an entity type.
+ *
+ * @param $type
+ *   The entity type the mapping refers to.
+ * @param $bundle
+ *   The bundle the mapping refers to.
+ * @param $mapping
+ *   An associative array representing an RDF mapping structure. The required
+ *   keys and values are
+ *     type: The entity type the mapping refers to.
+ *     bundle: The bundle the mapping refers to.
+ *     mapping: An array describing the mapping of this bundle/entity.
+ * @return bool
+ */
+function rdf_update_mapping($type, $bundle, $mapping) {
+  $fields = array('mapping' => serialize($mapping));
+  $num_rows = db_update('rdf_mapping')->fields($fields)
+    ->condition('type', $type)->condition('bundle', $bundle)->execute();
+
+  return ($num_rows > 0);
+}
+
+/**
+ * Delete the mapping for the given pair of type and bundle from the database.
+ *
+ * @param $type
+ *   The entity type the mapping refers to.
+ * @param $bundle
+ *   The bundle the mapping refers to.
+ * @return bool
+ */
+function rdf_delete_mapping($type, $bundle) {
+  $num_rows = db_delete('rdf_mapping')->condition('type', $type)
+    ->condition('bundle', $bundle)->execute();
+
+  return ($num_rows > 0);
+}

=== added file 'modules/rdf/rdf.info'
--- modules/rdf/rdf.info	1970-01-01 00:00:00 +0000
+++ modules/rdf/rdf.info	2009-10-03 17:25:00 +0000
@@ -0,0 +1,10 @@
+; $Id$
+name = RDF
+description = Allows to map the site data structure to RDF and export it in RDFa.
+package = Core
+version = VERSION
+core = 7.x
+files[] = rdf.install
+files[] = rdf.module
+files[] = rdf.crud.inc
+files[] = rdf.test

=== added file 'modules/rdf/rdf.install'
--- modules/rdf/rdf.install	1970-01-01 00:00:00 +0000
+++ modules/rdf/rdf.install	2009-10-03 17:25:00 +0000
@@ -0,0 +1,40 @@
+<?php
+// $Id$
+
+/**
+ * @file
+ * Install, update and uninstall functions for the rdf module.
+ */
+
+/**
+ * Implement hook_schema().
+ */
+function rdf_schema() {
+  $schema['rdf_mapping'] = array(
+    'description' => 'Stores custom RDF mappings for user defined content types or overriden module-defined mappings',
+    'fields' => array(
+      'type' => array(
+        'type' => 'varchar',
+        'length' => 255,
+        'not null' => TRUE,
+        'description' => 'The name of the entity type a mapping applies to (node, user, comment, etc.).',
+      ),
+      'bundle' => array(
+        'type' => 'varchar',
+        'length' => 128,
+        'not null' => TRUE,
+        'description' => 'The name of the bundle a mapping applies to.',
+      ),
+      'mapping' => array(
+        'description' => 'The serialized mapping of the bundle type and fields to RDF terms.',
+        'type' => 'text',
+        'not null' => FALSE,
+        'size' => 'big',
+        'serialize' => TRUE,
+      ),
+    ),
+    'primary key' => array('type', 'bundle'),
+  );
+
+  return $schema;
+}

=== added file 'modules/rdf/rdf.module'
--- modules/rdf/rdf.module	1970-01-01 00:00:00 +0000
+++ modules/rdf/rdf.module	2009-10-07 20:51:04 +0000
@@ -0,0 +1,333 @@
+<?php
+// $Id$
+
+/**
+ * @file
+ * Enables semantically enriched output for Drupal sites.
+ *
+ * RDFa primer...
+ *
+ * Modules can provide mappings of their bundles' data and metadata to RDFa
+ * properties using the appropriate vocabularies. This module takes care of
+ * injecting that data into variables available to themers in the .tpl files.
+ * Drupal core themes ship with RDFa output enabled.
+ *
+ * Example mapping from comment.module:
+ * array(
+ *   'comment' => array(
+ *     'rdftype' => array('sioct:Post'),
+ *     'title'   => array(
+ *       'property' => array('dc:title'),
+ *     ),
+ *     'created' => array(
+ *       'property' => array('dc:date', 'dc:created'),
+ *       'datatype' => 'xsd:dateTime',
+ *       'callback' => 'date_iso8601',
+ *     ),
+ *     'replyof' => array(
+ *       'property' => array('sioc:reply_of'),
+ *     ),
+ *     'name' => array(
+ *       'property' => array('dc:creator'),
+ *     ),
+ *   )
+ * );
+ */
+
+/*
+ * Load all public RDF CRUD API functions. Drupal currently has no
+ * mechanism for auto-loading core APIs, so we have to load them on
+ * every page request.
+ */
+require(DRUPAL_ROOT . '/modules/rdf/rdf.crud.inc');
+
+/**
+ * Returns the mapping for the attributes of the given bundle.
+ *
+ * @param $type
+ *   An entity type.
+ * @param $bundle
+ *   A bundle name.
+ * @return array
+ *   The mapping corresponding to the requested type, bundle combo.
+ */
+function rdf_get_mapping($type, $bundle) {
+  // Retrieve the mapping from the entity info.
+  $entity_info = entity_get_info($type);
+  return !empty($entity_info['bundles'][$bundle]['rdf_mapping']) ? $entity_info['bundles'][$bundle]['rdf_mapping'] : NULL;
+}
+
+/**
+ * Saves an RDF mapping to the database.
+ *
+ * Takes a mapping structure returned by hook_rdf_mapping() implementations
+ * and creates or updates a record mapping for each encountered
+ * type, bundle pair. If available, adds default values for non-existent
+ * mapping keys.
+ *
+ * @param $mapping
+ *   The RDF mapping to save, as an array.
+ * @return
+ *   Status flag indicating the outcome of the operation.
+ */
+function rdf_save_mapping($mapping) {
+  // Adds default values for non-existent keys.
+  $new_mapping = $mapping['mapping'] + _rdf_get_default_mapping($mapping['type']);
+  $exists = (bool)rdf_read_mapping($mapping['type'], $mapping['bundle']);
+
+  if ($exists) {
+    rdf_update_mapping($mapping['type'], $mapping['bundle'], $new_mapping);
+    return SAVED_UPDATED;
+  }
+  else {
+    rdf_create_mapping($mapping['type'], $mapping['bundle'], $new_mapping);
+    return SAVED_NEW;
+  }
+
+  cache_clear_all('entity_info', 'cache');
+  drupal_static_reset('entity_get_info');
+}
+
+/**
+ * Implements hook_modules_installed().
+ *
+ * Checks if the installed modules have any RDF mapping definitions to declare
+ * and stores them in the rdf_mapping table.
+ */
+function rdf_modules_installed($modules) {
+  // We need to clear the caches of entity_info as this is not done right
+  // during the tests. see http://drupal.org/node/594234
+  cache_clear_all('entity_info', 'cache');
+  drupal_static_reset('entity_get_info');
+
+  foreach ($modules as $module) {
+    if (function_exists($module . '_rdf_mapping')) {
+      $mapping_array = call_user_func($module . '_rdf_mapping');
+      foreach ($mapping_array as $mapping) {
+        rdf_save_mapping($mapping);
+      }
+    }
+  }
+}
+
+/**
+ * Implements hook_modules_uninstalled().
+ */
+function rdf_modules_uninstalled($modules) {
+// TODO remove the RDF mappings.
+}
+
+/**
+ * Implements hook_entity_info_alter().
+ *
+ * Adds the proper RDF mapping to each entity type, bundle pair.
+ */
+function rdf_entity_info_alter(&$entity_info) {
+  // Loop through each entity type and its bundles.
+  foreach ($entity_info as $entity_type => $entity_type_info) {
+    if (isset($entity_type_info['bundles'])) {
+      foreach ($entity_type_info['bundles'] as $bundle => $bundle_info) {
+        if ($mapping = rdf_read_mapping($entity_type, $bundle)) {
+          $entity_info[$entity_type]['bundles'][$bundle]['rdf_mapping'] = $mapping;
+        }
+        else {
+          // If no mapping was found in the database, assign the default RDF
+          // mapping for this entity type.
+          $entity_info[$entity_type]['bundles'][$bundle]['rdf_mapping'] = _rdf_get_default_mapping($entity_type);
+        }
+      }
+    }
+  }
+}
+
+/**
+ * Returns ready to render RDFa attributes for the given mapping.
+ *
+ * @param $mapping
+ *   An array containing a mandatory property key and optional datatype and
+ *   callback keys.
+ *   Example:
+ *   array(
+ *     'property' => array('dc:created'),
+ *     'datatype' => 'xsd:dateTime',
+ *     'callback' => 'date_iso8601',
+ *   )
+ * @param $data
+ *   A value that needs to be converted by the provided callback function.
+ * @return array
+ *   An array containing RDFa attributes ready for rendering.
+ */
+function drupal_rdfa_attributes($mapping, $data = NULL) {
+  $attributes['property'] = $mapping['property'];
+
+  if (isset($mapping['callback']) && isset($data)) {
+    $callback = $mapping['callback'];
+
+    if (function_exists($callback)) {
+      $attributes['content'] = call_user_func($callback, $data);
+    }
+    if (isset($mapping['datatype'])) {
+      $attributes['datatype'] = $mapping['datatype'];
+    }
+  }
+
+  return $attributes;
+}
+
+/**
+ * Implements hook_node_load().
+ */
+function rdf_node_load($nodes, $types) {
+  foreach ($nodes as $node) {
+    $node->rdf_mapping = rdf_get_mapping('node', $node->type);
+    // The node_load function does not reuse user_load(), so we need to
+    // regenerate the URI of the author of the node.
+    $node->rdf['user'] = array('uri' => _rdf_generate_user_uri($node->uid));
+  }
+}
+
+/**
+ * Implements hook_user_load().
+ */
+function rdf_user_load($users) {
+  // Generate an RDF resource URI for each user account.
+  foreach ($users as $user) {
+    $user->rdf = array('uri' => _rdf_generate_user_uri($user->uid));
+  }
+}
+
+/**
+ * Implements hook_comment_view().
+ *
+ * @param $comments
+ *   An array of comment objects.
+ */
+function rdf_comment_view($comment){
+  $comment->rdf_mapping = rdf_get_mapping('comment', $comment->node_type);
+}
+
+/**
+ * Helper function to create a URI for the user object.
+ *
+ * @param $uid
+ *   The user id the URI should be generated from.
+ * @return
+ *   A URI including the base path of the site, e.g. '/subdomain/user/1#user'.
+ */
+function _rdf_generate_user_uri($uid) {
+  return base_path() . 'user/' . $uid . '#user';
+}
+
+/**
+ * Returns an ISO8601 formatted date based on the given date.
+ *
+ * Can be used as a callback for mappings.
+ *
+ * @param $date
+ *   A unix timestamp.
+ * @return string
+ *   An ISO8601 formatted date.
+ */
+function date_iso8601($date) {
+  return date(DATE_ISO8601, $date);
+}
+
+/**
+ * Implements MODULE_preprocess_HOOK().
+ */
+function rdf_preprocess_node(&$variables) {
+  // Add RDFa markup to the node container. The about attribute specifies the
+  // URI of the resource described within the HTML element, while the typeof
+  // attribute indicates its RDF type (foaf:Document, or sioc:User, etc.).
+  $variables['attributes_array']['about'] = empty($variables['node_url']) ? NULL: $variables['node_url'];
+  $variables['attributes_array']['typeof'] = empty($variables['node']->rdf_mapping['rdftype']) ? NULL : $variables['node']->rdf_mapping['rdftype'];
+
+  // Add RDFa markup to the title of the node. Because the RDFa markup is added
+  // to the h2 tag which might contain HTML code, we specify an empty datatype
+  // to ensure the value of the title read by the RDFa parsers is a literal.
+  $variables['title_attributes_array']['property'] = empty($variables['node']->rdf_mapping['title']['property']) ? NULL : $variables['node']->rdf_mapping['title']['property'];
+  $variables['title_attributes_array']['datatype'] = '';
+
+  // In full node mode, the title is not displayed by node.tpl.php so it is
+  // added in the head tag of the HTML page.
+  if ($variables['page']) {
+    $title_attributes['property'] = empty($variables['node']->rdf_mapping['title']['property']) ? NULL : $variables['node']->rdf_mapping['title']['property'];
+    $title_attributes['content'] = $variables['title'];
+    drupal_add_html_head('<meta' . drupal_attributes($title_attributes) . ' />');
+  }
+
+  // Add RDFa markup for the date.
+  // TODO use a theme_timestamp() function instead? see http://drupal.org/node/574954
+  if (!empty($variables['rdf_mapping']['created'])) {
+    $date_attributes_array = drupal_rdfa_attributes($variables['rdf_mapping']['created'], $variables['created']);
+    $variables['date'] = '<span ' . drupal_attributes($date_attributes_array) .  '>' . $variables['date'] . '</span>';
+  }
+}
+
+/**
+ * Adds RDFa attributes to the template variables.
+ *
+ * @param $variables
+ */
+function rdf_preprocess_field(&$variables) {
+  $entity_type = $variables['element']['#object_type'];
+  $instance = $variables['instance'];
+  $mapping = rdf_get_mapping($entity_type, $instance['bundle']);
+  $field_name = $instance['field_name'];
+
+  if (!empty($mapping) && !empty($mapping[$field_name])) {
+    foreach ($variables['items'] as $delta => $item) {
+      $variables['item_attributes_array'][$delta] = drupal_rdfa_attributes($mapping[$field_name], $item['#item']);
+    }
+  }
+}
+
+/**
+ * Implements MODULE_preprocess_HOOK().
+ */
+function rdf_preprocess_username(&$variables) {
+  if (!empty($variables['object']->account->rdf_mapping['name'])) {
+    if (isset($variables['object']->link_path)) {
+      $variables['object']->link_attributes['rel'] = $variables['object']->account->rdf_mapping['uid']['property'];
+    }
+    else {
+      $variables['object']->attributes['property'] = $variables['object']->account->rdf_mapping['name']['property'];
+    }
+  }
+}
+
+/**
+ * Implements MODULE_preprocess_HOOK().
+ */
+function rdf_preprocess_comment(&$variables) {
+  if (!empty($variables['comment']->rdf_mapping['rdftype'])) {
+    $variables['attributes_array']['typeof'] = $variables['comment']->rdf_mapping['rdftype'];
+  }
+  if (!empty($variables['comment']->rdf_mapping['title'])) {
+    $variables['title_attributes_array']['property'] = $variables['comment']->rdf_mapping['title']['property'];
+    $variables['title_attributes_array']['datatype'] = '';
+  }
+  if (!empty($variables['comment']->rdf_mapping['created'])) {
+    $date_attributes_array = drupal_rdfa_attributes($variables['comment']->rdf_mapping['created'], $variables['comment']->timestamp);
+    $variables['date'] = '<span ' . drupal_attributes($date_attributes_array) .  '>' . $variables['date'] . '</span>';
+  }
+}
+
+/**
+ * Returns the default RDFa mapping for the given entity type.
+ *
+ * @param $type
+ *   An entity type.
+ * @return array
+ *   The RDFa mappings or an empty array.
+ */
+function _rdf_get_default_mapping($type) {
+  $default_mappings = array();
+  $function = "{$type}_rdf_mapping_defaults";
+
+  if (function_exists($function)) {
+    $default_mappings = call_user_func($function);
+  }
+
+  return $default_mappings;
+}

=== added file 'modules/rdf/rdf.test'
--- modules/rdf/rdf.test	1970-01-01 00:00:00 +0000
+++ modules/rdf/rdf.test	2009-10-08 13:21:18 +0000
@@ -0,0 +1,3 @@
+<?php
+// $Id$
+

=== added directory 'modules/rdf/tests'
=== added file 'modules/rdf/tests/rdf_test.info'
--- modules/rdf/tests/rdf_test.info	1970-01-01 00:00:00 +0000
+++ modules/rdf/tests/rdf_test.info	2009-10-07 12:51:57 +0000
@@ -0,0 +1,9 @@
+; $Id$
+name = "RDF module tests"
+description = "Support module for RDF module testing."
+package = Testing
+version = VERSION
+core = 7.x
+files[] = rdf_test.install
+files[] = rdf_test.module
+hidden = TRUE

=== added file 'modules/rdf/tests/rdf_test.install'
--- modules/rdf/tests/rdf_test.install	1970-01-01 00:00:00 +0000
+++ modules/rdf/tests/rdf_test.install	2009-10-07 17:39:17 +0000
@@ -0,0 +1,26 @@
+<?php
+// $Id$
+
+/**
+ * @file
+ * Install, update and uninstall functions for the rdf module.
+ */
+
+/**
+ * Implement hook_install().
+ */
+function rdf_test_install() {
+  $rdf_mappings = array(
+    array(
+      'type' => 'node',
+      'bundle' => 'test_bundle_hook_install',
+      'mapping' => array(
+        'rdftype' => array('foo:mapping_install1', 'bar:mapping_install2'),
+      ),
+    ),
+  );
+
+  foreach ($rdf_mappings as $rdf_mapping) {
+    rdf_save_mapping($rdf_mapping);
+  }
+}

=== added file 'modules/rdf/tests/rdf_test.module'
--- modules/rdf/tests/rdf_test.module	1970-01-01 00:00:00 +0000
+++ modules/rdf/tests/rdf_test.module	2009-10-08 00:58:56 +0000
@@ -0,0 +1,44 @@
+<?php
+// $Id$
+
+/**
+ * @file
+ * Dummy module implementing RDF related hooks to test API interaction with
+ * the RDF module.
+ */
+
+/**
+ * Implementation of hook_rdf_mapping().
+ */
+function rdf_test_rdf_mapping() {
+  return array(
+    0 => array(
+      'type' => 'test_entity', 
+      'bundle' => 'test_bundle',
+      'mapping' => array(
+        'rdftype' => array('sioc:Post'),
+        'title' => array(
+          'property' => array('dc:title'),
+        ),
+        'created' => array(
+          'property' => array('dc:created'),
+          'datatype' => 'xsd:dateTime',
+          'callback' => 'date_iso8601',
+        ),
+        'uid' => array(
+          'property' => array('sioc:has_creator', 'dc:creator'),
+        ),
+        'foobar' => array(
+          'property' => array('foo:bar'),
+        ),
+      ),
+    ),
+    1 => array(
+      'type' => 'node',
+      'bundle' => 'blog',
+      'mapping' => array(
+        'rdftype' => array('sioct:Weblog'),
+      )
+    ),
+  );
+}