diff --git a/helper/geojsonify.js b/helper/geojsonify.js
index 1f9a60a8..67fed28e 100644
--- a/helper/geojsonify.js
+++ b/helper/geojsonify.js
@@ -34,6 +34,8 @@ var DETAILS_PROPS = [
   'locality',
   'locality_id',
   'locality_a',
+  'borough',
+  'borough_id',
   'neighbourhood',
   'neighbourhood_id',
   'bounding_box'
diff --git a/helper/labelGenerator.js b/helper/labelGenerator.js
index 0f0eb9dd..eb35c86c 100644
--- a/helper/labelGenerator.js
+++ b/helper/labelGenerator.js
@@ -4,37 +4,28 @@ var _ = require('lodash'),
 module.exports = function( record ){
   var schema = getSchema(record.country_a);
 
+  // in virtually all cases, this will be the `name` field
   var labelParts = getInitialLabel(record);
 
-  for (var key in schema) {
-    var valueFunction = schema[key];
-
-    labelParts = valueFunction(record, labelParts);
+  // iterate the schema
+  for (var field in schema) {
+    var valueFunction = schema[field];
+    labelParts.push(valueFunction(record));
   }
 
-  // NOTE: while it may seem odd to call `uniq` on the list of label parts,
-  //  the effect is quite subtle.  Take, for instance, a result for "Lancaster, PA"
-  //  the pseudo-object is:
-  //  {
-  //    'name': 'Lancaster',
-  //    'locality': 'Lancaster',
-  //    'region_a': 'PA',
-  //    'country_a': 'USA'
-  //  }
-  //
-  //  the code up to this point generates the label:
-  //  `Lancaster, Lancaster, PA, USA`
-  //
-  //  then the `unique` call reduces this to:
-  //  `Lancaster, PA, USA`
-  //
-  //  this code doesn't have the same effect in the case of a venue or address
-  //  where the `name` field would contain the address or name of a point-of-interest
-  //
-  //  Also see https://github.com/pelias/api/issues/429 for other ways that this is bad
-  //
-  // de-dupe, join, trim
-  return _.uniq( labelParts ).join(', ').trim();
+  // retain only things that are defined
+  labelParts = labelParts.filter(function(v) { return !_.isUndefined(v); });
+
+  // first, dedupe the name and 1st label array elements
+  //  this is used to ensure that the `name` and first admin hierarchy elements aren't repeated
+  //  eg - `["Lancaster", "Lancaster", "PA", "United States"]` -> `["Lancaster", "PA", "United States"]`
+  var dedupedNameAndFirstLabelElement = _.uniq([labelParts.shift(), labelParts.shift()]);
+
+  // second, unshift the deduped parts back onto the labelParts
+  labelParts.unshift.apply(labelParts, dedupedNameAndFirstLabelElement);
+
+  // third, join with a comma and return
+  return labelParts.join(', ');
 
 };
 
diff --git a/helper/labelSchema.js b/helper/labelSchema.js
index 5d3eba5d..e1f9921a 100644
--- a/helper/labelSchema.js
+++ b/helper/labelSchema.js
@@ -1,66 +1,62 @@
-var _ = require('lodash'),
-    check = require('check-types');
+var _ = require('lodash');
 
 module.exports = {
-  'USA': {
-    'local': getFirstProperty(['localadmin', 'locality', 'neighbourhood', 'county']),
-    'regional': getUsState,
-    'country': getFirstProperty(['country_a'])
+  'default': {
+    'local': getFirstProperty(['locality']),
+    'country': getFirstProperty(['country'])
   },
   'GBR': {
-    'local': getFirstProperty(['neighbourhood', 'county', 'localadmin', 'locality', 'macroregion', 'region']),
-    'regional': getFirstProperty(['county','country','region'])
-  },
-  'SGP': {
-    'local': getFirstProperty(['neighbourhood', 'region', 'county', 'localadmin', 'locality']),
-    'regional': getFirstProperty(['county','country','region'])
+    'local': getFirstProperty(['locality']),
+    'regional': getFirstProperty(['macroregion']),
+    'country': getFirstProperty(['country'])
   },
-  'SWE': {
-    'local': getFirstProperty(['neighbourhood', 'region', 'county', 'localadmin', 'locality']),
-    'regional': getFirstProperty(['country'])
+  'USA': {
+    'borough': getFirstProperty(['borough']),
+    'local': getFirstProperty(['locality']),
+    'regional': getUsOrCaState,
+    'country': getFirstProperty(['country'])
   },
-  'default': {
-    'local': getFirstProperty(['localadmin', 'locality', 'neighbourhood', 'county', 'macroregion', 'region']),
-    'regional': getFirstProperty(['country'])
+  'CAN': {
+    'local': getFirstProperty(['locality']),
+    'regional': getUsOrCaState,
+    'country': getFirstProperty(['country'])
   }
 };
 
 // find the first field of record that has a non-empty value that's not already in labelParts
 function getFirstProperty(fields) {
-  return function(record, labelParts) {
+  return function(record) {
     for (var i = 0; i < fields.length; i++) {
       var fieldValue = record[fields[i]];
 
-      if (check.nonEmptyString(fieldValue) && !_.includes(labelParts, fieldValue)) {
-        labelParts.push( fieldValue );
-        return labelParts;
+      if (!_.isEmpty(fieldValue)) {
+        return fieldValue;
       }
 
     }
 
-    return labelParts;
-
   };
 
 }
 
-// this function is exclusively used for figuring out which field to use for US States
-// 1.  if a US state is the most granular bit of info entered, the label should contain
-//  the full state name, eg: Pennsylvania, USA
-// 2.  otherwise, the state abbreviation should be used, eg: Lancaster, PA, USA
+// this function is exclusively used for figuring out which field to use for US/CA States
+// 1.  if a US/CA state is the most granular bit of info entered, the label should contain
+//  the full state name, eg: Pennsylvania, USA and Ontario, CA
+// 2.  otherwise, the state abbreviation should be used, eg: Lancaster, PA, USA and Bruce, ON, CA
 // 3.  if for some reason the abbreviation isn't available, use the full state name
-function getUsState(record, labelParts) {
+function getUsOrCaState(record) {
   if ('region' === record.layer && record.region) {
-    // add full state name when state is the most granular piece of info
-    labelParts.push(record.region);
+    // return full state name when state is the most granular piece of info
+    return record.region;
+
   } else if (record.region_a) {
-    // otherwise just add the region code when available
-    labelParts.push(record.region_a);
+    // otherwise just return the region code when available
+    return record.region_a;
+
   } else if (record.region) {
-    // add the full name when there's no region code available ()
-    labelParts.push(record.region);
-  }
+    // return the full name when there's no region code available
+    return record.region;
 
-  return labelParts;
+  }
 
 }
diff --git a/test/unit/helper/geojsonify.js b/test/unit/helper/geojsonify.js
index 7b371b27..51704170 100644
--- a/test/unit/helper/geojsonify.js
+++ b/test/unit/helper/geojsonify.js
@@ -57,6 +57,7 @@ module.exports.tests.search = function(test, common) {
       'country': 'United Kingdom',
       'region': 'Islington',
       'region_a': 'ISL',
+      'macroregion': 'England',
       'county': 'Angel',
       'localadmin': 'test1',
       'locality': 'test2',
@@ -82,6 +83,7 @@ module.exports.tests.search = function(test, common) {
       'country': 'United Kingdom',
       'region': 'City And County Of The City Of London',
       'region_a': 'COL',
+      'macroregion': 'England',
       'county': 'Smithfield',
       'localadmin': 'test1',
       'locality': 'test2',
@@ -104,7 +106,7 @@ module.exports.tests.search = function(test, common) {
       'region': 'New York',
       'region_a': 'NY',
       'county': 'New York',
-      'localadmin': 'Manhattan',
+      'borough': 'Manhattan',
       'locality': 'New York',
       'neighbourhood': 'Koreatown',
       'category': [
@@ -132,10 +134,11 @@ module.exports.tests.search = function(test, common) {
           'gid': 'source1:layer1:id1',
           'layer': 'layer1',
           'source': 'source1',
-          'label': '\'Round Midnight Jazz and Blues Bar, test3, Angel',
+          'label': '\'Round Midnight Jazz and Blues Bar, test2, England, United Kingdom',
           'name': '\'Round Midnight Jazz and Blues Bar',
           'country_a': 'GBR',
           'country': 'United Kingdom',
+          'macroregion': 'England',
           'region': 'Islington',
           'region_a': 'ISL',
           'county': 'Angel',
@@ -161,10 +164,11 @@ module.exports.tests.search = function(test, common) {
           'gid': 'source2:layer2:id2',
           'layer': 'layer2',
           'source': 'source2',
-          'label': 'Blues Cafe, test3, Smithfield',
+          'label': 'Blues Cafe, test2, England, United Kingdom',
           'name': 'Blues Cafe',
           'country_a': 'GBR',
           'country': 'United Kingdom',
+          'macroregion': 'England',
           'region': 'City And County Of The City Of London',
           'region_a': 'COL',
           'county': 'Smithfield',
@@ -187,14 +191,14 @@ module.exports.tests.search = function(test, common) {
           'gid': 'openstreetmap:venue:node:34633854',
           'layer': 'venue',
           'source': 'openstreetmap',
-          'label': 'Empire State Building, Manhattan, NY, USA',
+          'label': 'Empire State Building, Manhattan, New York, NY, United States',
           'name': 'Empire State Building',
           'country_a': 'USA',
           'country': 'United States',
           'region': 'New York',
           'region_a': 'NY',
           'county': 'New York',
-          'localadmin': 'Manhattan',
+          'borough': 'Manhattan',
           'locality': 'New York',
           'neighbourhood': 'Koreatown'
         }
@@ -204,6 +208,7 @@ module.exports.tests.search = function(test, common) {
 
   test('geojsonify.search(doc)', function(t) {
     var json = geojsonify.search( input );
+
     t.deepEqual(json, expected, 'all docs mapped');
     t.end();
   });
@@ -282,13 +287,13 @@ module.exports.tests.search = function(test, common) {
         'county_a': [
           null
         ],
-        'localadmin': [
+        'borough': [
           'Brooklyn'
         ],
-        'localadmin_id': [
+        'borough_id': [
           '404521211'
         ],
-        'localadmin_a': [
+        'borough_a': [
           null
         ],
         'locality_id': [
@@ -329,8 +334,8 @@ module.exports.tests.search = function(test, common) {
             'macrocounty_a': 'MacroCounty Abbreviation',
             'county': 'Kings County',
             'county_id': '102082361',
-            'localadmin': 'Brooklyn',
-            'localadmin_id': '404521211',
+            'borough': 'Brooklyn',
+            'borough_id': '404521211',
             'locality': 'New York',
             'locality_id': '85977539',
             'bounding_box': {
@@ -339,7 +344,7 @@ module.exports.tests.search = function(test, common) {
               'min_lon': -73.8967895508,
               'max_lon': -73.8665771484
             },
-            'label': 'East New York, Brooklyn, NY, USA'
+            'label': 'East New York, Brooklyn, New York, NY, United States'
           },
           'geometry': {
             'type': 'Point',
@@ -353,6 +358,7 @@ module.exports.tests.search = function(test, common) {
     };
 
     var json = geojsonify.search( input );
+
     t.deepEqual(json, expected, 'all wanted properties exposed');
     t.end();
   });
diff --git a/test/unit/helper/labelGenerator_CAN.js b/test/unit/helper/labelGenerator_CAN.js
new file mode 100644
index 00000000..f78a5a53
--- /dev/null
+++ b/test/unit/helper/labelGenerator_CAN.js
@@ -0,0 +1,205 @@
+var generator = require('../../../helper/labelGenerator');
+
+module.exports.tests = {};
+
+module.exports.tests.interface = function(test, common) {
+  test('interface', function(t) {
+    t.equal(typeof generator, 'function', 'valid function');
+    t.end();
+  });
+};
+
+module.exports.tests.canada = function(test, common) {
+  test('venue', function(t) {
+    var doc = {
+      'name': 'venue name',
+      'layer': 'venue',
+      'housenumber': '1',
+      'street': 'Main St',
+      'neighbourhood': 'neighbourhood name',
+      'locality': 'locality name',
+      'localadmin': 'localadmin name',
+      'county': 'county name',
+      'macrocounty': 'macrocounty name',
+      'region_a': 'region abbr',
+      'region': 'region name',
+      'macroregion': 'macroregion name',
+      'country_a': 'CAN',
+      'country': 'Canada'
+    };
+    t.equal(generator(doc),'venue name, locality name, region abbr, Canada');
+    t.end();
+  });
+
+  test('street', function(t) {
+    var doc = {
+      'name': '1 Main St',
+      'layer': 'address',
+      'housenumber': '1',
+      'street': 'Main St',
+      'neighbourhood': 'neighbourhood name',
+      'locality': 'locality name',
+      'localadmin': 'localadmin name',
+      'county': 'county name',
+      'macrocounty': 'macrocounty name',
+      'region_a': 'region abbr',
+      'region': 'region name',
+      'macroregion': 'macroregion name',
+      'country_a': 'CAN',
+      'country': 'Canada'
+    };
+    t.equal(generator(doc),'1 Main St, locality name, region abbr, Canada');
+    t.end();
+  });
+
+  test('neighbourhood', function(t) {
+    var doc = {
+      'name': 'neighbourhood name',
+      'layer': 'neighbourhood',
+      'neighbourhood': 'neighbourhood name',
+      'locality': 'locality name',
+      'localadmin': 'localadmin name',
+      'county': 'county name',
+      'macrocounty': 'macrocounty name',
+      'region_a': 'region abbr',
+      'region': 'region name',
+      'macroregion': 'macroregion name',
+      'country_a': 'CAN',
+      'country': 'Canada'
+    };
+    t.equal(generator(doc),'neighbourhood name, locality name, region abbr, Canada');
+    t.end();
+  });
+
+  test('locality', function(t) {
+    var doc = {
+      'name': 'locality name',
+      'layer': 'locality',
+      'locality': 'locality name',
+      'localadmin': 'localadmin name',
+      'county': 'county name',
+      'macrocounty': 'macrocounty name',
+      'region_a': 'region abbr',
+      'region': 'region name',
+      'macroregion': 'macroregion name',
+      'country_a': 'CAN',
+      'country': 'Canada'
+    };
+    t.equal(generator(doc),'locality name, region abbr, Canada');
+    t.end();
+  });
+
+  test('localadmin', function(t) {
+    var doc = {
+      'name': 'localadmin name',
+      'layer': 'localadmin',
+      'localadmin': 'localadmin name',
+      'county': 'county name',
+      'macrocounty': 'macrocounty name',
+      'region_a': 'region abbr',
+      'region': 'region name',
+      'macroregion': 'macroregion name',
+      'country_a': 'CAN',
+      'country': 'Canada'
+    };
+    t.equal(generator(doc),'localadmin name, region abbr, Canada');
+    t.end();
+  });
+
+  test('county', function(t) {
+    var doc = {
+      'name': 'county name',
+      'layer': 'county',
+      'county': 'county name',
+      'macrocounty': 'macrocounty name',
+      'region_a': 'region abbr',
+      'region': 'region name',
+      'macroregion': 'macroregion name',
+      'country_a': 'CAN',
+      'country': 'Canada'
+    };
+    t.equal(generator(doc),'county name, region abbr, Canada');
+    t.end();
+  });
+
+  test('macrocounty', function(t) {
+    var doc = {
+      'name': 'macrocounty name',
+      'layer': 'macrocounty',
+      'macrocounty': 'macrocounty name',
+      'region_a': 'region abbr',
+      'region': 'region name',
+      'macroregion': 'macroregion name',
+      'country_a': 'CAN',
+      'country': 'Canada'
+    };
+    t.equal(generator(doc),'macrocounty name, region abbr, Canada');
+    t.end();
+  });
+
+  test('region', function(t) {
+    var doc = {
+      'name': 'region name',
+      'layer': 'region',
+      'region_a': 'region abbr',
+      'region': 'region name',
+      'macroregion': 'macroregion name',
+      'country_a': 'CAN',
+      'country': 'Canada'
+    };
+    t.equal(generator(doc),'region name, Canada');
+    t.end();
+  });
+
+  test('macroregion', function(t) {
+    var doc = {
+      'name': 'macroregion name',
+      'layer': 'macroregion',
+      'macroregion': 'macroregion name',
+      'country_a': 'CAN',
+      'country': 'Canada'
+    };
+    t.equal(generator(doc),'macroregion name, Canada');
+    t.end();
+  });
+
+  test('country', function(t) {
+    var doc = {
+      'name': 'Canada',
+      'layer': 'country',
+      'country_a': 'CAN',
+      'country': 'Canada'
+    };
+    t.equal(generator(doc),'Canada');
+    t.end();
+  });
+
+  test('region should be used when region_a is not available', function(t) {
+    var doc = {
+      'name': 'locality name',
+      'layer': 'region',
+      'locality': 'locality name',
+      'localadmin': 'localadmin name',
+      'county': 'county name',
+      'macrocounty': 'macrocounty name',
+      'region': 'region name',
+      'macroregion': 'macroregion name',
+      'country_a': 'CAN',
+      'country': 'Canada'
+    };
+    t.equal(generator(doc),'locality name, region name, Canada', 'region should be used');
+    t.end();
+  });
+
+};
+
+module.exports.all = function (tape, common) {
+
+  function test(name, testFunction) {
+    return tape('label generator (CAN): ' + name, testFunction);
+  }
+
+  for( var testCase in module.exports.tests ){
+    module.exports.tests[testCase](test, common);
+  }
+};
diff --git a/test/unit/helper/labelGenerator_GBR.js b/test/unit/helper/labelGenerator_GBR.js
index a0f74312..4b619464 100644
--- a/test/unit/helper/labelGenerator_GBR.js
+++ b/test/unit/helper/labelGenerator_GBR.js
@@ -10,69 +10,164 @@ module.exports.tests.interface = function(test, common) {
   });
 };
 
-// GBR street address
-module.exports.tests.one_main_street_uk = function(test, common) {
-  test('one main street uk', function(t) {
+module.exports.tests.united_kingdom = function(test, common) {
+  test('venue', function(t) {
     var doc = {
-      'name': '1 Main St',
+      'name': 'venue name',
+      'layer': 'venue',
       'housenumber': '1',
       'street': 'Main St',
-      'postalcode': 'BT77 0BG',
+      'neighbourhood': 'neighbourhood name',
+      'locality': 'locality name',
+      'localadmin': 'localadmin name',
+      'county': 'county name',
+      'macrocounty': 'macrocounty name',
+      'region': 'region name',
+      'macroregion': 'macroregion name',
       'country_a': 'GBR',
-      'country': 'United Kingdom',
-      'region': 'Dungannon'
+      'country': 'United Kingdom'
     };
-    t.equal(generator(doc),'1 Main St, Dungannon, United Kingdom');
+    t.equal(generator(doc),'venue name, locality name, macroregion name, United Kingdom');
     t.end();
   });
-};
 
-// GBR venue
-module.exports.tests.hackney_city_farm = function(test, common) {
-  test('hackney city farm', function(t) {
+  test('street', function(t) {
     var doc = {
-      'name': 'Hackney City Farm',
+      'name': 'street address',
+      'layer': 'address',
+      'housenumber': '1',
+      'street': 'Main St',
+      'neighbourhood': 'neighbourhood name',
+      'locality': 'locality name',
+      'localadmin': 'localadmin name',
+      'county': 'county name',
+      'macrocounty': 'macrocounty name',
+      'region': 'region name',
+      'macroregion': 'macroregion name',
       'country_a': 'GBR',
-      'country': 'United Kingdom',
-      'region': 'Hackney',
-      'county': 'Greater London',
-      'locality': 'London',
-      'neighbourhood': 'Haggerston'
+      'country': 'United Kingdom'
     };
-    t.equal(generator(doc),'Hackney City Farm, Haggerston, Greater London');
+    t.equal(generator(doc),'street address, locality name, macroregion name, United Kingdom');
     t.end();
   });
-};
 
-// GBR country
-module.exports.tests.wales = function(test, common) {
-  test('wales', function(t) {
+  test('neighbourhood', function(t) {
     var doc = {
-      'name': 'Wales',
+      'name': 'neighbourhood name',
+      'layer': 'neighbourhood',
+      'neighbourhood': 'neighbourhood name',
+      'locality': 'locality name',
+      'localadmin': 'localadmin name',
+      'county': 'county name',
+      'macrocounty': 'macrocounty name',
+      'region': 'region name',
+      'macroregion': 'macroregion name',
       'country_a': 'GBR',
-      'country': 'United Kingdom',
-      'region': 'Wales'
+      'country': 'United Kingdom'
     };
-    t.equal(generator(doc),'Wales, United Kingdom');
+    t.equal(generator(doc),'neighbourhood name, locality name, macroregion name, United Kingdom');
+    t.end();
+  });
+
+  test('locality', function(t) {
+    var doc = {
+      'name': 'locality name',
+      'layer': 'locality',
+      'locality': 'locality name',
+      'localadmin': 'localadmin name',
+      'county': 'county name',
+      'macrocounty': 'macrocounty name',
+      'region': 'region name',
+      'macroregion': 'macroregion name',
+      'country_a': 'GBR',
+      'country': 'United Kingdom'
+    };
+    t.equal(generator(doc),'locality name, macroregion name, United Kingdom');
+    t.end();
+  });
+
+  test('localadmin', function(t) {
+    var doc = {
+      'name': 'localadmin name',
+      'layer': 'localadmin',
+      'localadmin': 'localadmin name',
+      'county': 'county name',
+      'macrocounty': 'macrocounty name',
+      'region': 'region name',
+      'macroregion': 'macroregion name',
+      'country_a': 'GBR',
+      'country': 'United Kingdom'
+    };
+    t.equal(generator(doc),'localadmin name, macroregion name, United Kingdom');
+    t.end();
+  });
+
+  test('county', function(t) {
+    var doc = {
+      'name': 'county name',
+      'layer': 'county',
+      'county': 'county name',
+      'macrocounty': 'macrocounty name',
+      'region': 'region name',
+      'macroregion': 'macroregion name',
+      'country_a': 'GBR',
+      'country': 'United Kingdom'
+    };
+    t.equal(generator(doc),'county name, macroregion name, United Kingdom');
+    t.end();
+  });
+
+  test('macrocounty', function(t) {
+    var doc = {
+      'name': 'macrocounty name',
+      'layer': 'macrocounty',
+      'macrocounty': 'macrocounty name',
+      'region': 'region name',
+      'macroregion': 'macroregion name',
+      'country_a': 'GBR',
+      'country': 'United Kingdom'
+    };
+    t.equal(generator(doc),'macrocounty name, macroregion name, United Kingdom');
     t.end();
   });
-};
 
-// GBR macroregion
-module.exports.tests.macroregion_trumps_region = function(test, common) {
-  test('macroregion should trump region when none of neighbourhood, county, localadmin, locality are available', function(t) {
+  test('region', function(t) {
     var doc = {
-      'name': 'Name',
+      'name': 'region name',
+      'layer': 'region',
+      'region': 'region name',
+      'macroregion': 'macroregion name',
       'country_a': 'GBR',
-      'country': 'Country Name',
-      'macroregion': 'Macroregion Name',
-      'region': 'Region Name'
+      'country': 'United Kingdom'
     };
+    t.equal(generator(doc),'region name, macroregion name, United Kingdom');
+    t.end();
+  });
 
-    t.equal(generator(doc), 'Name, Macroregion Name, Country Name');
+  test('macroregion', function(t) {
+    var doc = {
+      'name': 'macroregion name',
+      'layer': 'macroregion',
+      'macroregion': 'macroregion name',
+      'country_a': 'GBR',
+      'country': 'United Kingdom'
+    };
+    t.equal(generator(doc),'macroregion name, United Kingdom');
     t.end();
+  });
 
+  test('country', function(t) {
+    var doc = {
+      'name': 'United Kingdom',
+      'layer': 'country',
+      'postalcode': 'postalcode',
+      'country_a': 'GBR',
+      'country': 'United Kingdom'
+    };
+    t.equal(generator(doc),'United Kingdom');
+    t.end();
   });
+
 };
 
 module.exports.all = function (tape, common) {
diff --git a/test/unit/helper/labelGenerator_SGP.js b/test/unit/helper/labelGenerator_SGP.js
deleted file mode 100644
index 622f8915..00000000
--- a/test/unit/helper/labelGenerator_SGP.js
+++ /dev/null
@@ -1,51 +0,0 @@
-
-var generator = require('../../../helper/labelGenerator');
-
-module.exports.tests = {};
-
-module.exports.tests.interface = function(test, common) {
-  test('interface', function(t) {
-    t.equal(typeof generator, 'function', 'valid function');
-    t.end();
-  });
-};
-
-// SGP region
-module.exports.tests.north_west_singapore = function(test, common) {
-  test('north west singapore', function(t) {
-    var doc = {
-      'name': 'North West',
-      'country_a': 'SGP',
-      'country': 'Singapore',
-      'region': 'North West'
-    };
-    t.equal(generator(doc),'North West, Singapore');
-    t.end();
-  });
-};
-
-// SGP venue
-module.exports.tests.singapore_mcdonalds = function(test, common) {
-  test('singapore_mcdonalds', function(t) {
-    var doc = {
-      'name': 'McDonald\'s',
-      'country_a': 'SGP',
-      'country': 'Singapore',
-      'region': 'Central Singapore',
-      'locality': 'Singapore'
-    };
-    t.equal(generator(doc),'McDonald\'s, Central Singapore, Singapore');
-    t.end();
-  });
-};
-
-module.exports.all = function (tape, common) {
-
-  function test(name, testFunction) {
-    return tape('label generator: ' + name, testFunction);
-  }
-
-  for( var testCase in module.exports.tests ){
-    module.exports.tests[testCase](test, common);
-  }
-};
diff --git a/test/unit/helper/labelGenerator_SWE.js b/test/unit/helper/labelGenerator_SWE.js
deleted file mode 100644
index e3f8534d..00000000
--- a/test/unit/helper/labelGenerator_SWE.js
+++ /dev/null
@@ -1,53 +0,0 @@
-
-var generator = require('../../../helper/labelGenerator');
-
-module.exports.tests = {};
-
-module.exports.tests.interface = function(test, common) {
-  test('interface', function(t) {
-    t.equal(typeof generator, 'function', 'valid function');
-    t.end();
-  });
-};
-
-// SWE city
-module.exports.tests.skane1 = function(test, common) {
-  test('skåne 1', function(t) {
-    var doc = {
-      'name': 'Malmö',
-      'country_a': 'SWE',
-      'country': 'Sweden',
-      'region': 'Skåne',
-      'county': 'Malmö'
-    };
-    t.equal(generator(doc),'Malmö, Skåne, Sweden');
-    t.end();
-  });
-};
-
-// SWE city
-module.exports.tests.skane2 = function(test, common) {
-  test('skåne 2', function(t) {
-    var doc = {
-      'name': 'Malmö',
-      'country_a': 'SWE',
-      'country': 'Sweden',
-      'region': 'Skåne',
-      'county': 'Malmö',
-      'locality': 'Malmö'
-    };
-    t.equal(generator(doc),'Malmö, Skåne, Sweden');
-    t.end();
-  });
-};
-
-module.exports.all = function (tape, common) {
-
-  function test(name, testFunction) {
-    return tape('label generator: ' + name, testFunction);
-  }
-
-  for( var testCase in module.exports.tests ){
-    module.exports.tests[testCase](test, common);
-  }
-};
diff --git a/test/unit/helper/labelGenerator_USA.js b/test/unit/helper/labelGenerator_USA.js
index 7791aa24..57e77f32 100644
--- a/test/unit/helper/labelGenerator_USA.js
+++ b/test/unit/helper/labelGenerator_USA.js
@@ -9,218 +9,213 @@ module.exports.tests.interface = function(test, common) {
   });
 };
 
-module.exports.tests.localadmin = function(test, common) {
-  test('localadmin should trump locality, neighbourhood, and county', function(t) {
+module.exports.tests.united_states = function(test, common) {
+  test('venue', function(t) {
     var doc = {
-      'name': 'Default Name',
+      'name': 'venue name',
+      'layer': 'venue',
+      'housenumber': '1',
+      'street': 'Main St',
+      'neighbourhood': 'neighbourhood name',
+      'locality': 'locality name',
+      'localadmin': 'localadmin name',
+      'county': 'county name',
+      'macrocounty': 'macrocounty name',
+      'region_a': 'region abbr',
+      'region': 'region name',
+      'macroregion': 'macroregion name',
       'country_a': 'USA',
-      'country': 'United States',
-      'region': 'Region Name',
-      'region_a': 'Region Abbr',
-      'county': 'County Name',
-      'localadmin': 'LocalAdmin Name',
-      'locality': 'Locality Name',
-      'neighbourhood': 'Neighbourhood Name'
+      'country': 'United States'
     };
-    t.equal(generator(doc),'Default Name, LocalAdmin Name, Region Abbr, USA');
+    t.equal(generator(doc),'venue name, locality name, region abbr, United States');
     t.end();
   });
-};
 
-module.exports.tests.locality = function(test, common) {
-  test('locality should trump neighbourhood and county when localadmin not available', function(t) {
+  test('street', function(t) {
     var doc = {
-      'name': 'Default Name',
+      'name': '1 Main St',
+      'layer': 'address',
+      'housenumber': '1',
+      'street': 'Main St',
+      'neighbourhood': 'neighbourhood name',
+      'locality': 'locality name',
+      'localadmin': 'localadmin name',
+      'county': 'county name',
+      'macrocounty': 'macrocounty name',
+      'region_a': 'region abbr',
+      'region': 'region name',
+      'macroregion': 'macroregion name',
       'country_a': 'USA',
-      'country': 'United States',
-      'region': 'Region Name',
-      'region_a': 'Region Abbr',
-      'county': 'County Name',
-      'locality': 'Locality Name',
-      'neighbourhood': 'Neighbourhood Name'
+      'country': 'United States'
     };
-    t.equal(generator(doc),'Default Name, Locality Name, Region Abbr, USA');
+    t.equal(generator(doc),'1 Main St, locality name, region abbr, United States');
     t.end();
   });
-};
 
-module.exports.tests.neighbourhood = function(test, common) {
-  test('neighbourhood should trump county when neither localadmin nor locality', function(t) {
+  test('neighbourhood', function(t) {
     var doc = {
-      'name': 'Default Name',
+      'name': 'neighbourhood name',
+      'layer': 'neighbourhood',
+      'neighbourhood': 'neighbourhood name',
+      'locality': 'locality name',
+      'localadmin': 'localadmin name',
+      'county': 'county name',
+      'macrocounty': 'macrocounty name',
+      'region_a': 'region abbr',
+      'region': 'region name',
+      'macroregion': 'macroregion name',
       'country_a': 'USA',
-      'country': 'United States',
-      'region': 'Region Name',
-      'region_a': 'Region Abbr',
-      'county': 'County Name',
-      'neighbourhood': 'Neighbourhood Name'
+      'country': 'United States'
     };
-    t.equal(generator(doc),'Default Name, Neighbourhood Name, Region Abbr, USA');
+    t.equal(generator(doc),'neighbourhood name, locality name, region abbr, United States');
     t.end();
   });
-};
 
-module.exports.tests.county = function(test, common) {
-  test('county should be used when localadmin, locality, and neighbourhood are not available', function(t) {
+  test('venue in borough', function(t) {
     var doc = {
-      'name': 'Default Name',
+      'name': 'venue name',
+      'layer': 'borough',
+      'neighbourhood': 'neighbourhood name',
+      'borough': 'borough name',
+      'locality': 'locality name',
+      'localadmin': 'localadmin name',
+      'county': 'county name',
+      'macrocounty': 'macrocounty name',
+      'region_a': 'region abbr',
+      'region': 'region name',
+      'macroregion': 'macroregion name',
       'country_a': 'USA',
-      'country': 'United States',
-      'region': 'Region Name',
-      'region_a': 'Region Abbr',
-      'county': 'County Name'
+      'country': 'United States'
     };
-    t.equal(generator(doc),'Default Name, County Name, Region Abbr, USA');
+    t.equal(generator(doc),'venue name, borough name, locality name, region abbr, United States');
     t.end();
   });
-};
 
-module.exports.tests.region = function(test, common) {
-  test('region should be used when region_a is not available', function(t) {
+  test('locality', function(t) {
     var doc = {
-      'name': 'Default Name',
+      'name': 'locality name',
+      'layer': 'locality',
+      'locality': 'locality name',
+      'localadmin': 'localadmin name',
+      'county': 'county name',
+      'macrocounty': 'macrocounty name',
+      'region_a': 'region abbr',
+      'region': 'region name',
+      'macroregion': 'macroregion name',
       'country_a': 'USA',
-      'country': 'United States',
-      'region': 'Region Name'
+      'country': 'United States'
     };
-    t.equal(generator(doc),'Default Name, Region Name, USA');
+    t.equal(generator(doc),'locality name, region abbr, United States');
     t.end();
   });
-};
 
-// USA geonames state
-module.exports.tests.region_geonames = function(test, common) {
-  test('default name should not be prepended when source=geonames and layer=region', function(t) {
+  test('localadmin', function(t) {
     var doc = {
-      'name': 'Region Name',
+      'name': 'localadmin name',
+      'layer': 'localadmin',
+      'localadmin': 'localadmin name',
+      'county': 'county name',
+      'macrocounty': 'macrocounty name',
+      'region_a': 'region abbr',
+      'region': 'region name',
+      'macroregion': 'macroregion name',
       'country_a': 'USA',
-      'country': 'United States',
-      'region': 'Region Name',
-      'region_a': 'Region Abbr',
-      'source': 'geonames',
-      'layer': 'region'
+      'country': 'United States'
     };
-    t.equal(generator(doc),'Region Name, USA');
+    t.equal(generator(doc),'localadmin name, region abbr, United States');
     t.end();
   });
-};
 
-// USA whosonfirst state
-module.exports.tests.region_whosonfirst = function(test, common) {
-  test('default name should not be prepended when source=whosonfirst and layer=region', function(t) {
+  test('county', function(t) {
     var doc = {
-      'name': 'Region Name',
+      'name': 'county name',
+      'layer': 'county',
+      'county': 'county name',
+      'macrocounty': 'macrocounty name',
+      'region_a': 'region abbr',
+      'region': 'region name',
+      'macroregion': 'macroregion name',
       'country_a': 'USA',
-      'country': 'United States',
-      'region': 'Region Name',
-      'region_a': 'Region Abbr',
-      'source': 'whosonfirst',
-      'layer': 'region'
+      'country': 'United States'
     };
-    t.equal(generator(doc),'Region Name, USA');
+    t.equal(generator(doc),'county name, region abbr, United States');
     t.end();
   });
-};
 
-// USA non-geonames/whosonfirst state
-module.exports.tests.region_other_source = function(test, common) {
-  test('default name should be prepended when layer=region and source is not whosonfirst or geonames', function(t) {
+  test('macrocounty', function(t) {
     var doc = {
-      'name': 'Default Name',
+      'name': 'macrocounty name',
+      'layer': 'macrocounty',
+      'macrocounty': 'macrocounty name',
+      'region_a': 'region abbr',
+      'region': 'region name',
+      'macroregion': 'macroregion name',
       'country_a': 'USA',
-      'country': 'United States',
-      'region': 'Region Name',
-      'region_a': 'Region Abbr',
-      'source': 'not geonames or whosonfirst',
-      'layer': 'region'
+      'country': 'United States'
     };
-    t.equal(generator(doc),'Default Name, Region Name, USA',generator(doc));
+    t.equal(generator(doc),'macrocounty name, region abbr, United States');
     t.end();
   });
-};
 
-// major USA city
-module.exports.tests.san_francisco = function(test, common) {
-  test('san francisco', function(t) {
+  test('region', function(t) {
     var doc = {
-      'name': 'San Francisco',
+      'name': 'region name',
+      'layer': 'region',
+      'region_a': 'region abbr',
+      'region': 'region name',
+      'macroregion': 'macroregion name',
       'country_a': 'USA',
-      'country': 'United States',
-      'region': 'California',
-      'region_a': 'CA',
-      'county': 'San Francisco County',
-      'locality': 'San Francisco'
+      'country': 'United States'
     };
-    t.equal(generator(doc),'San Francisco, San Francisco County, CA, USA');
+    t.equal(generator(doc),'region name, United States');
     t.end();
   });
-};
 
-// USA venue
-module.exports.tests.nyc_office = function(test, common) {
-  test('30 West 26th Street', function(t) {
+  test('macroregion', function(t) {
     var doc = {
-      'name': '30 West 26th Street',
-      'housenumber': '30',
-      'street': 'West 26th Street',
-      'postalcode': '10010',
+      'name': 'macroregion name',
+      'layer': 'macroregion',
+      'macroregion': 'macroregion name',
       'country_a': 'USA',
-      'country': 'United States',
-      'region': 'New York',
-      'region_a': 'NY',
-      'county': 'New York County',
-      'localadmin': 'Manhattan',
-      'locality': 'New York',
-      'neighbourhood': 'Flatiron District'
+      'country': 'United States'
     };
-    t.equal(generator(doc),'30 West 26th Street, Manhattan, NY, USA');
+    t.equal(generator(doc),'macroregion name, United States');
     t.end();
   });
-};
 
-// USA NYC eatery
-module.exports.tests.nyc_bakery = function(test, common) {
-  test('New York Bakery', function(t) {
+  test('country', function(t) {
     var doc = {
-      'name': 'New York Bakery',
-      'housenumber': '51 W',
-      'street': '29th',
+      'name': 'United States',
+      'layer': 'country',
       'country_a': 'USA',
-      'country': 'United States',
-      'region': 'New York',
-      'region_a': 'NY',
-      'county': 'New York County',
-      'localadmin': 'Manhattan',
-      'locality': 'New York',
-      'neighbourhood': 'Koreatown'
+      'country': 'United States'
     };
-    t.equal(generator(doc),'New York Bakery, Manhattan, NY, USA');
+    t.equal(generator(doc),'United States');
     t.end();
   });
-};
 
-// USA SFC building
-module.exports.tests.ferry_building = function(test, common) {
-  test('Ferry Building', function(t) {
+  test('region should be used when region_a is not available', function(t) {
     var doc = {
-      'name': 'Ferry Building',
+      'name': 'locality name',
+      'locality': 'locality name',
+      'localadmin': 'localadmin name',
+      'county': 'county name',
+      'macrocounty': 'macrocounty name',
+      'region': 'region name',
+      'macroregion': 'macroregion name',
       'country_a': 'USA',
-      'country': 'United States',
-      'region': 'California',
-      'region_a': 'CA',
-      'county': 'San Francisco County',
-      'locality': 'San Francisco',
-      'neighbourhood': 'Financial District'
+      'country': 'United States'
     };
-    t.equal(generator(doc),'Ferry Building, San Francisco, CA, USA');
+    t.equal(generator(doc),'locality name, region name, United States', 'region should be used');
     t.end();
   });
+
 };
 
 module.exports.all = function (tape, common) {
 
   function test(name, testFunction) {
-    return tape('label generator: ' + name, testFunction);
+    return tape('label generator (USA): ' + name, testFunction);
   }
 
   for( var testCase in module.exports.tests ){
diff --git a/test/unit/helper/labelGenerator_default.js b/test/unit/helper/labelGenerator_default.js
index cbb76f05..7645610f 100644
--- a/test/unit/helper/labelGenerator_default.js
+++ b/test/unit/helper/labelGenerator_default.js
@@ -10,296 +10,163 @@ module.exports.tests.interface = function(test, common) {
   });
 };
 
-// AUS state
-module.exports.tests.new_south_wales = function(test, common) {
-  test('new south wales', function(t) {
+module.exports.tests.default_country = function(test, common) {
+  test('venue', function(t) {
     var doc = {
-      'name': 'New South Wales',
-      'country_a': 'AUS',
-      'country': 'Australia',
-      'region': 'New South Wales'
-    };
-    t.equal(generator(doc),'New South Wales, Australia');
-    t.end();
-  });
-};
-
-// IND state
-module.exports.tests.west_bengal = function(test, common) {
-  test('west bengal', function(t) {
-    var doc = {
-      'name': 'West Bengal',
-      'country_a': 'IND',
-      'country': 'India',
-      'region': 'West Bengal'
-    };
-    t.equal(generator(doc),'West Bengal, India');
-    t.end();
-  });
-};
-
-// IND city
-module.exports.tests.bangalore = function(test, common) {
-  test('bangalore', function(t) {
-    var doc = {
-      'name': 'Bangalore',
-      'country_a': 'IND',
-      'country': 'India',
-      'region': 'Karnataka',
-      'county': 'Bangalore',
-      'locality': 'Bangalore'
-    };
-    t.equal(generator(doc),'Bangalore, Karnataka, India');
-    t.end();
-  });
-};
-
-// IND region of city
-module.exports.tests.sarjapur = function(test, common) {
-  test('Sarjapur', function(t) {
-    var doc = {
-      'name': 'Sarjapur',
-      'country_a': 'IND',
-      'country': 'India',
-      'region': 'Karnataka'
-    };
-    t.equal(generator(doc),'Sarjapur, Karnataka, India');
-    t.end();
-  });
-};
-
-// IND region of city 2
-module.exports.tests.bengaluru_east = function(test, common) {
-  test('Bengaluru East', function(t) {
-    var doc = {
-      'name': 'Bengaluru East',
-      'country_a': 'IND',
-      'country': 'India',
-      'region': 'Karnataka',
-      'county': 'Bangalore',
-      'locality': 'Bangalore',
-      'neighbourhood': 'Fraser Town'
-    };
-    t.equal(generator(doc),'Bengaluru East, Bangalore, India');
-    t.end();
-  });
-};
-
-// AUS area
-// https://en.wikipedia.org/wiki/Shire_of_Wellington
-module.exports.tests.wellington_victoria = function(test, common) {
-  test('Wellington, Victoria, Australia', function(t) {
-    var doc = {
-      'name': 'Wellington',
-      'country_a': 'AUS',
-      'country': 'Australia',
-      'region': 'Victoria',
-      'county': 'Wellington'
-    };
-    t.equal(generator(doc),'Wellington, Victoria, Australia');
-    t.end();
-  });
-};
-
-// IRQ region
-module.exports.tests.arbil = function(test, common) {
-  test('arbil', function(t) {
-    var doc = {
-      'name': 'Arbil',
-      'country_a': 'IRQ',
-      'country': 'Iraq',
-      'region': 'Arbil'
-    };
-    t.equal(generator(doc),'Arbil, Iraq');
-    t.end();
-  });
-};
-
-// ESP city
-module.exports.tests.madrid = function(test, common) {
-  test('madrid', function(t) {
-    var doc = {
-      'name': 'Madrid',
-      'country_a': 'ESP',
-      'country': 'Spain',
-      'region': 'Madrid'
-    };
-    t.equal(generator(doc),'Madrid, Spain');
-    t.end();
-  });
-};
-
-// DEU street address
-module.exports.tests.one_grolmanstrasse = function(test, common) {
-  test('one grolmanstrasse', function(t) {
-    var doc = {
-      'name': '1 Grolmanstraße',
+      'name': 'venue name',
+      'layer': 'venue',
       'housenumber': '1',
-      'street': 'Grolmanstraße',
-      'postalcode': '10623',
-      'country_a': 'DEU',
-      'country': 'Germany',
-      'region': 'Berlin',
-      'county': 'Berlin',
-      'locality': 'Berlin',
-      'neighbourhood': 'Halensee'
+      'street': 'Main St',
+      'neighbourhood': 'neighbourhood name',
+      'locality': 'locality name',
+      'localadmin': 'localadmin name',
+      'county': 'county name',
+      'macrocounty': 'macrocounty name',
+      'region': 'region name',
+      'macroregion': 'macroregion name',
+      'country_a': 'country code',
+      'country': 'country name'
     };
-    t.equal(generator(doc),'1 Grolmanstraße, Berlin, Germany');
+    t.equal(generator(doc),'venue name, locality name, country name');
     t.end();
   });
-};
-
-// NZD country
-module.exports.tests.new_zealand = function(test, common) {
-  test('new zealand', function(t) {
-    var doc = {
-      'name': 'New Zealand',
-      'country_a': 'NZL',
-      'country': 'New Zealand'
-    };
-    t.equal(generator(doc),'New Zealand');
-    t.end();
-  });
-};
 
-// IRL country
-module.exports.tests.republic_of_ireland = function(test, common) {
-  test('northern ireland', function(t) {
+  test('street', function(t) {
     var doc = {
-      'name': 'Ireland',
-      'country_a': 'IRL',
-      'country': 'Ireland'
+      'name': 'address',
+      'layer': 'address',
+      'housenumber': '1',
+      'street': 'Main St',
+      'neighbourhood': 'neighbourhood name',
+      'locality': 'locality name',
+      'localadmin': 'localadmin name',
+      'county': 'county name',
+      'macrocounty': 'macrocounty name',
+      'region': 'region name',
+      'macroregion': 'macroregion name',
+      'country_a': 'country code',
+      'country': 'country name'
     };
-    // !! this is not part of the UK !!
-    t.equal(generator(doc),'Ireland');
+    t.equal(generator(doc),'address, locality name, country name');
     t.end();
   });
-};
 
-// THA province
-module.exports.tests.krabi_province = function(test, common) {
-  test('Krabi Provence', function(t) {
+  test('neighbourhood', function(t) {
     var doc = {
-      'name': 'Krabi',
-      'country_a': 'THA',
-      'country': 'Thailand',
-      'region': 'Krabi'
+      'name': 'neighbourhood name',
+      'layer': 'neighbourhood',
+      'neighbourhood': 'neighbourhood name',
+      'locality': 'locality name',
+      'localadmin': 'localadmin name',
+      'county': 'county name',
+      'macrocounty': 'macrocounty name',
+      'region': 'region name',
+      'macroregion': 'macroregion name',
+      'country_a': 'country code',
+      'country': 'country name'
     };
-    t.equal(generator(doc),'Krabi, Thailand');
+    t.equal(generator(doc),'neighbourhood name, locality name, country name');
     t.end();
   });
-};
 
-// THA island
-module.exports.tests.koh_lanta = function(test, common) {
-  test('Koh Lanta', function(t) {
+  test('locality', function(t) {
     var doc = {
-      'name': 'Ko Lanta',
-      'country_a': 'THA',
-      'country': 'Thailand',
-      'region': 'Krabi'
+      'name': 'locality name',
+      'layer': 'locality',
+      'locality': 'locality name',
+      'localadmin': 'localadmin name',
+      'county': 'county name',
+      'macrocounty': 'macrocounty name',
+      'region': 'region name',
+      'macroregion': 'macroregion name',
+      'country_a': 'country code',
+      'country': 'country name'
     };
-    t.equal(generator(doc),'Ko Lanta, Krabi, Thailand');
+    t.equal(generator(doc),'locality name, country name');
     t.end();
   });
-};
 
-// NZD cafe
-module.exports.tests.black_dog_cafe = function(test, common) {
-  test('Black Dog Cafe', function(t) {
+  test('localadmin', function(t) {
     var doc = {
-      'name': 'Black Dog Cafe',
-      'country_a': 'NZL',
-      'country': 'New Zealand',
-      'region': 'Auckland Region',
-      'county': 'Auckland'
+      'name': 'localadmin name',
+      'layer': 'localadmin',
+      'localadmin': 'localadmin name',
+      'county': 'county name',
+      'macrocounty': 'macrocounty name',
+      'region': 'region name',
+      'macroregion': 'macroregion name',
+      'country_a': 'country code',
+      'country': 'country name'
     };
-    t.equal(generator(doc),'Black Dog Cafe, Auckland, New Zealand');
+    t.equal(generator(doc),'localadmin name, country name');
     t.end();
   });
-};
 
-// NZD cafe 2
-module.exports.tests.beach_bablyon = function(test, common) {
-  test('Beach Bablyon', function(t) {
+  test('county', function(t) {
     var doc = {
-      'name': 'Beach Bablyon',
-      'country_a': 'NZL',
-      'country': 'New Zealand',
-      'region': 'Wellington Region',
-      'county': 'Wellington City',
-      'locality': 'Wellington',
-      'neighbourhood': 'Oriental Bay'
+      'name': 'county name',
+      'layer': 'county',
+      'county': 'county name',
+      'macrocounty': 'macrocounty name',
+      'region': 'region name',
+      'macroregion': 'macroregion name',
+      'country_a': 'country code',
+      'country': 'country name'
     };
-    t.equal(generator(doc),'Beach Bablyon, Wellington, New Zealand');
+    t.equal(generator(doc),'county name, country name');
     t.end();
   });
-};
 
-// NZD tourism
-module.exports.tests.waiotapu = function(test, common) {
-  test('Waiotapu', function(t) {
+  test('macrocounty', function(t) {
     var doc = {
-      'name': 'Waiotapu',
-      'country_a': 'NZL',
-      'country': 'New Zealand',
-      'region': 'Bay of Plenty',
-      'county': 'Rotorua District'
+      'name': 'macrocounty name',
+      'layer': 'macrocounty',
+      'macrocounty': 'macrocounty name',
+      'region': 'region name',
+      'macroregion': 'macroregion name',
+      'country_a': 'country code',
+      'country': 'country name'
     };
-    t.equal(generator(doc),'Waiotapu, Rotorua District, New Zealand');
+    t.equal(generator(doc),'macrocounty name, country name');
     t.end();
   });
-};
 
-
-module.exports.tests.non_us_or_ca_region = function(test, common) {
-  test('geonames US', function(t) {
+  test('region', function(t) {
     var doc = {
-      'name': 'Default Name',
-      'country_a': 'XYZ',
-      'country': 'Full Country Name',
-      'region': 'Full Region Name',
+      'name': 'region name',
       'layer': 'region',
-      'source': 'geonames'
+      'region': 'region name',
+      'macroregion': 'macroregion name',
+      'country_a': 'country code',
+      'country': 'country name'
     };
-
-    t.equal(generator(doc), 'Default Name, Full Region Name, Full Country Name');
+    t.equal(generator(doc),'region name, country name');
     t.end();
-
   });
 
-  test('whosonfirst US', function(t) {
+  test('macroregion', function(t) {
     var doc = {
-      'name': 'Default Name',
-      'country_a': 'XYZ',
-      'country': 'Full Country Name',
-      'region': 'Full Region Name',
-      'layer': 'region',
-      'source': 'whosonfirst'
+      'name': 'macroregion name',
+      'layer': 'macroregion',
+      'macroregion': 'macroregion name',
+      'country_a': 'country code',
+      'country': 'country name'
     };
-
-    t.equal(generator(doc), 'Default Name, Full Region Name, Full Country Name');
+    t.equal(generator(doc),'macroregion name, country name');
     t.end();
-
   });
 
-};
-
-// macroregion
-module.exports.tests.macroregion_trumps_region = function(test, common) {
-  test('macroregion should trump region when none of localadmin, locality, neighbourhood, county are available', function(t) {
+  test('country', function(t) {
     var doc = {
-      'name': 'Name',
-      'country_a': 'Country abbreviation',
-      'country': 'Country Name',
-      'macroregion': 'Macroregion Name',
-      'region': 'Region Name'
+      'name': 'country name',
+      'layer': 'country',
+      'country_a': 'country code',
+      'country': 'country name'
     };
-
-    t.equal(generator(doc), 'Name, Macroregion Name, Country Name');
+    t.equal(generator(doc),'country name');
     t.end();
-
   });
+
 };
 
 module.exports.all = function (tape, common) {
diff --git a/test/unit/helper/labelGenerator_examples.js b/test/unit/helper/labelGenerator_examples.js
new file mode 100644
index 00000000..180c9b90
--- /dev/null
+++ b/test/unit/helper/labelGenerator_examples.js
@@ -0,0 +1,114 @@
+var generator = require('../../../helper/labelGenerator');
+
+module.exports.tests = {};
+
+module.exports.tests.interface = function(test, common) {
+  test('interface', function(t) {
+    t.equal(typeof generator, 'function', 'valid function');
+    t.end();
+  });
+};
+
+module.exports.tests.canada = function(test, common) {
+  test('venue', function(t) {
+    var doc = {
+      'name': 'Tim Horton\'s',
+      'layer': 'venue',
+      'housenumber': '1',
+      'street': 'Main St',
+      'neighbourhood': 'College Heights',
+      'locality': 'Thunder Bay',
+      'region_a': 'ON',
+      'region': 'Ontario',
+      'country_a': 'CAN',
+      'country': 'Canada'
+    };
+    t.equal(generator(doc),'Tim Horton\'s, Thunder Bay, ON, Canada');
+    t.end();
+  });
+
+  test('address', function(t) {
+    var doc = {
+      'name': '1 Main St',
+      'layer': 'venue',
+      'housenumber': '1',
+      'street': 'Main St',
+      'locality': 'Truth or Consequences',
+      'region_a': 'NM',
+      'region': 'New Mexico',
+      'country_a': 'USA',
+      'country': 'United States'
+    };
+    t.equal(generator(doc),'1 Main St, Truth or Consequences, NM, United States');
+    t.end();
+  });
+
+  test('eiffel tower', function(t) {
+    var doc = {
+      'name': 'Tour Eiffel',
+      'layer': 'venue',
+      'neighbourhood': 'Quartier du Gros-Caillou',
+      'locality': 'Paris',
+      'region': 'Paris',
+      'country_a': 'FRA',
+      'country': 'France'
+    };
+    t.equal(generator(doc),'Tour Eiffel, Paris, France');
+    t.end();
+  });
+
+  test('France street address', function(t) {
+    var doc = {
+      'name': '74 rue de rivoli',
+      'layer': 'address',
+      'housenumber': '74',
+      'street': 'Rue de Rivoli',
+      'neighbourhood': 'Quartier Saint-Merri',
+      'locality': 'Paris',
+      'region': 'Paris',
+      'country_a': 'FRA',
+      'country': 'France'
+    };
+    t.equal(generator(doc),'74 rue de rivoli, Paris, France');
+    t.end();
+  });
+
+  test('France neighbourhood', function(t) {
+    var doc = {
+      'name': 'Grange aux Belles Terrage',
+      'layer': 'neighbourhood',
+      'neighbourhood': 'Grange aux Belles Terrage',
+      'locality': 'Paris',
+      'region': 'Paris',
+      'country_a': 'FRA',
+      'country': 'France'
+    };
+    t.equal(generator(doc),'Grange aux Belles Terrage, Paris, France');
+    t.end();
+  });
+
+  test('Luxembourg (the city) in Luxembourg', function(t) {
+    var doc = {
+      'name': 'Luxembourg',
+      'layer': 'locality',
+      'locality': 'Luxembourg',
+      'country_a': 'LUX',
+      'country': 'Luxembourg'
+    };
+    // console.error(generator(doc));
+    t.equal(generator(doc),'Luxembourg, Luxembourg');
+    t.end();
+  });
+
+};
+
+module.exports.all = function (tape, common) {
+
+  function test(name, testFunction) {
+    return tape('label generator (CAN): ' + name, testFunction);
+  }
+
+  for( var testCase in module.exports.tests ){
+    module.exports.tests[testCase](test, common);
+  }
+};
diff --git a/test/unit/helper/labelSchema.js b/test/unit/helper/labelSchema.js
index edbf2b77..9b0a35f3 100644
--- a/test/unit/helper/labelSchema.js
+++ b/test/unit/helper/labelSchema.js
@@ -13,20 +13,18 @@ module.exports.tests.interface = function(test, common) {
 };
 
 module.exports.tests.supported_countries = function(test, common) {
-  test('support countries', function(t) {
+  test('supported countries', function(t) {
     var supported_countries = Object.keys(schemas);
 
     t.notEquals(supported_countries.indexOf('USA'), -1);
+    t.notEquals(supported_countries.indexOf('CAN'), -1);
     t.notEquals(supported_countries.indexOf('GBR'), -1);
-    t.notEquals(supported_countries.indexOf('SGP'), -1);
-    t.notEquals(supported_countries.indexOf('SWE'), -1);
     t.notEquals(supported_countries.indexOf('default'), -1);
-    t.equals(supported_countries.length, 5);
+    t.equals(supported_countries.length, 4);
 
-    t.equals(Object.keys(schemas.USA).length, 3);
-    t.equals(Object.keys(schemas.GBR).length, 2);
-    t.equals(Object.keys(schemas.SGP).length, 2);
-    t.equals(Object.keys(schemas.SWE).length, 2);
+    t.equals(Object.keys(schemas.USA).length, 4);
+    t.equals(Object.keys(schemas.CAN).length, 3);
+    t.equals(Object.keys(schemas.GBR).length, 3);
     t.equals(Object.keys(schemas.default).length, 2);
 
     t.end();
@@ -34,746 +32,6 @@ module.exports.tests.supported_countries = function(test, common) {
   });
 };
 
-module.exports.tests.usa = function(test, common) {
-  test('USA.local should use localadmin value over locality, neighbourhood, and county', function(t) {
-    var record = {
-      localadmin: 'localadmin value',
-      locality: 'locality value',
-      neighbourhood: 'neighbourhood value',
-      county: 'county value'
-    };
-
-    var labelParts = ['initial value'];
-
-    var f = schemas.USA.local;
-
-    t.deepEqual(f(record, labelParts), ['initial value', 'localadmin value']);
-    t.end();
-
-  });
-
-  test('USA.local should use locality value over neighbourhood and county when no localadmin', function(t) {
-    var record = {
-      locality: 'locality value',
-      neighbourhood: 'neighbourhood value',
-      county: 'county value'
-    };
-
-    var labelParts = ['initial value'];
-
-    var f = schemas.USA.local;
-
-    t.deepEqual(f(record, labelParts), ['initial value', 'locality value']);
-    t.end();
-
-  });
-
-  test('USA.local should use neighbourhood value over county when no localadmin or locality', function(t) {
-    var record = {
-      neighbourhood: 'neighbourhood value',
-      county: 'county value'
-    };
-
-    var labelParts = ['initial value'];
-
-    var f = schemas.USA.local;
-
-    t.deepEqual(f(record, labelParts), ['initial value', 'neighbourhood value']);
-    t.end();
-
-  });
-
-  test('USA.local should use county value when no localadmin, locality, or neighbourhood', function(t) {
-    var record = {
-      county: 'county value'
-    };
-
-    var labelParts = ['initial value'];
-
-    var f = schemas.USA.local;
-
-    t.deepEqual(f(record, labelParts), ['initial value', 'county value']);
-    t.end();
-
-  });
-
-  test('USA.local should not modify labelParts if none of localadmin, locality, neighbourhood, or county is available', function(t) {
-    var record = {};
-
-    var labelParts = ['initial value'];
-
-    var f = schemas.USA.local;
-
-    t.deepEqual(f(record, labelParts), ['initial value']);
-    t.end();
-
-  });
-
-  test('USA.regional should use region when layer=region and region is available', function(t) {
-    var record = {
-      layer: 'region',
-      region: 'region name',
-      region_a: 'region_a name'
-    };
-
-    var labelParts = ['initial value'];
-
-    var f = schemas.USA.regional;
-
-    t.deepEqual(f(record, labelParts), ['initial value', 'region name']);
-    t.end();
-
-  });
-
-  test('USA.regional should use region_a when layer=region and region is unavailable', function(t) {
-    var record = {
-      layer: 'region',
-      region_a: 'region_a name'
-    };
-
-    var labelParts = ['initial value'];
-
-    var f = schemas.USA.regional;
-
-    t.deepEqual(f(record, labelParts), ['initial value', 'region_a name']);
-    t.end();
-
-  });
-
-  test('USA.regional should use region_a when layer!=region and both region and region_a are available', function(t) {
-    var record = {
-      layer: 'not region',
-      region: 'region name',
-      region_a: 'region_a name'
-    };
-
-    var labelParts = ['initial value'];
-
-    var f = schemas.USA.regional;
-
-    t.deepEqual(f(record, labelParts), ['initial value', 'region_a name']);
-    t.end();
-
-  });
-
-  test('USA.regional should use region when layer!=region and region_a is unavailable', function(t) {
-    var record = {
-      layer: 'region',
-      region: 'region name',
-      region_a: 'region_a name'
-    };
-
-    var labelParts = ['initial value'];
-
-    var f = schemas.USA.regional;
-
-    t.deepEqual(f(record, labelParts), ['initial value', 'region name'], 'region should have been appended');
-    t.end();
-
-  });
-
-  test('USA.regional should not append anything when neither region nor region_a are available', function(t) {
-    var record = {
-      layer: 'region',
-    };
-
-    var labelParts = ['initial value'];
-
-    var f = schemas.USA.regional;
-
-    t.deepEqual(f(record, labelParts), ['initial value'], 'no USA.region should have appended');
-    t.end();
-
-  });
-
-  test('USA.country should append country_a when available', function(t) {
-    var record = {
-      country_a: 'country_a name',
-      country: 'country name'
-    };
-
-    var labelParts = ['initial value'];
-
-    var f = schemas.USA.country;
-
-    t.deepEqual(f(record, labelParts), ['initial value', 'country_a name'], 'country_a should have appended');
-    t.end();
-
-  });
-
-  test('USA.country should not append anything when country_a is unavailable', function(t) {
-    var record = {
-      country: 'country name'
-    };
-
-    var labelParts = ['initial value'];
-
-    var f = schemas.USA.country;
-
-    t.deepEqual(f(record, labelParts), ['initial value'], 'no USA.country should have appended');
-    t.end();
-
-  });
-
-};
-
-module.exports.tests.gbr = function(test, common) {
-  test('GBR.local should use neighbourhood value over county, localadmin, locality, region', function(t) {
-    var record = {
-      neighbourhood: 'neighbourhood value',
-      county: 'county value',
-      localadmin: 'localadmin value',
-      locality: 'locality value',
-      region: 'region value'
-    };
-
-    var labelParts = ['initial value'];
-
-    var f = schemas.GBR.local;
-
-    t.deepEqual(f(record, labelParts), ['initial value', 'neighbourhood value']);
-    t.end();
-
-  });
-
-  test('GBR.local should use county value over county, localadmin, locality, region', function(t) {
-    var record = {
-      county: 'county value',
-      localadmin: 'localadmin value',
-      locality: 'locality value',
-      region: 'region value'
-    };
-
-    var labelParts = ['initial value'];
-
-    var f = schemas.GBR.local;
-
-    t.deepEqual(f(record, labelParts), ['initial value', 'county value']);
-    t.end();
-
-  });
-
-  test('GBR.local should use localadmin value over locality, region', function(t) {
-    var record = {
-      localadmin: 'localadmin value',
-      locality: 'locality value',
-      region: 'region value'
-    };
-
-    var labelParts = ['initial value'];
-
-    var f = schemas.GBR.local;
-
-    t.deepEqual(f(record, labelParts), ['initial value', 'localadmin value']);
-    t.end();
-
-  });
-
-  test('GBR.local should use locality value over region', function(t) {
-    var record = {
-      locality: 'locality value',
-      region: 'region value'
-    };
-
-    var labelParts = ['initial value'];
-
-    var f = schemas.GBR.local;
-
-    t.deepEqual(f(record, labelParts), ['initial value', 'locality value']);
-    t.end();
-
-  });
-
-  test('GBR.local should use region value when nothing else is available', function(t) {
-    var record = {
-      region: 'region value'
-    };
-
-    var labelParts = ['initial value'];
-
-    var f = schemas.GBR.local;
-
-    t.deepEqual(f(record, labelParts), ['initial value', 'region value']);
-    t.end();
-
-  });
-
-  test('GBR.local should not append anything when none of neighbourhood, county, localadmin, locality, region are available', function(t) {
-    var record = {};
-
-    var labelParts = ['initial value'];
-
-    var f = schemas.GBR.local;
-
-    t.deepEqual(f(record, labelParts), ['initial value']);
-    t.end();
-
-  });
-
-  test('GBR.regional should use county over country and region', function(t) {
-    var record = {
-      county: 'county value',
-      country: 'country value',
-      region: 'region value'
-    };
-
-    var labelParts = ['initial value'];
-
-    var f = schemas.GBR.regional;
-
-    t.deepEqual(f(record, labelParts), ['initial value', 'county value']);
-    t.end();
-
-  });
-
-  test('GBR.regional should use country over region', function(t) {
-    var record = {
-      country: 'country value',
-      region: 'region value'
-    };
-
-    var labelParts = ['initial value'];
-
-    var f = schemas.GBR.regional;
-
-    t.deepEqual(f(record, labelParts), ['initial value', 'country value']);
-    t.end();
-
-  });
-
-  test('GBR.regional should use region when county and country aren not available', function(t) {
-    var record = {
-      region: 'region value'
-    };
-
-    var labelParts = ['initial value'];
-
-    var f = schemas.GBR.regional;
-
-    t.deepEqual(f(record, labelParts), ['initial value', 'region value']);
-    t.end();
-
-  });
-
-  test('GBR.regional should not append anything when none of county, country, or region are available', function(t) {
-    var record = {};
-
-    var labelParts = ['initial value'];
-
-    var f = schemas.GBR.regional;
-
-    t.deepEqual(f(record, labelParts), ['initial value']);
-    t.end();
-
-  });
-
-};
-
-module.exports.tests.sgp = function(test, common) {
-  test('SGP.local should use neighbourhood value over region, county, localadmin, locality', function(t) {
-    var record = {
-      neighbourhood: 'neighbourhood value',
-      county: 'county value',
-      localadmin: 'localadmin value',
-      locality: 'locality value',
-      region: 'region value'
-    };
-
-    var labelParts = ['initial value'];
-
-    var f = schemas.SGP.local;
-
-    t.deepEqual(f(record, labelParts), ['initial value', 'neighbourhood value']);
-    t.end();
-
-  });
-
-  test('SGP.local should use region value over county, localadmin, locality', function(t) {
-    var record = {
-      county: 'county value',
-      localadmin: 'localadmin value',
-      locality: 'locality value',
-      region: 'region value'
-    };
-
-    var labelParts = ['initial value'];
-
-    var f = schemas.SGP.local;
-
-    t.deepEqual(f(record, labelParts), ['initial value', 'region value']);
-    t.end();
-
-  });
-
-  test('SGP.local should use county value over localadmin, locality', function(t) {
-    var record = {
-      localadmin: 'localadmin value',
-      locality: 'locality value',
-      county: 'county value'
-    };
-
-    var labelParts = ['initial value'];
-
-    var f = schemas.SGP.local;
-
-    t.deepEqual(f(record, labelParts), ['initial value', 'county value']);
-    t.end();
-
-  });
-
-  test('SGP.local should use localadmin value over locality', function(t) {
-    var record = {
-      localadmin: 'localadmin value',
-      locality: 'locality value'
-    };
-
-    var labelParts = ['initial value'];
-
-    var f = schemas.SGP.local;
-
-    t.deepEqual(f(record, labelParts), ['initial value', 'localadmin value']);
-    t.end();
-
-  });
-
-  test('SGP.local should use locality value when nothing else is available', function(t) {
-    var record = {
-      locality: 'locality value'
-    };
-
-    var labelParts = ['initial value'];
-
-    var f = schemas.SGP.local;
-
-    t.deepEqual(f(record, labelParts), ['initial value', 'locality value']);
-    t.end();
-
-  });
-
-  test('SGP.local should not append anything when none of neighbourhood, region, county, localadmin, locality are available', function(t) {
-    var record = {};
-
-    var labelParts = ['initial value'];
-
-    var f = schemas.SGP.local;
-
-    t.deepEqual(f(record, labelParts), ['initial value']);
-    t.end();
-
-  });
-
-  test('SGP.regional should use county over country and region', function(t) {
-    var record = {
-      county: 'county value',
-      country: 'country value',
-      region: 'region value'
-    };
-
-    var labelParts = ['initial value'];
-
-    var f = schemas.SGP.regional;
-
-    t.deepEqual(f(record, labelParts), ['initial value', 'county value']);
-    t.end();
-
-  });
-
-  test('SGP.regional should use country over region', function(t) {
-    var record = {
-      country: 'country value',
-      region: 'region value'
-    };
-
-    var labelParts = ['initial value'];
-
-    var f = schemas.SGP.regional;
-
-    t.deepEqual(f(record, labelParts), ['initial value', 'country value']);
-    t.end();
-
-  });
-
-  test('SGP.regional should use region when county and country aren not available', function(t) {
-    var record = {
-      region: 'region value'
-    };
-
-    var labelParts = ['initial value'];
-
-    var f = schemas.SGP.regional;
-
-    t.deepEqual(f(record, labelParts), ['initial value', 'region value']);
-    t.end();
-
-  });
-
-  test('SGP.regional should not append anything when none of county, country, or region are available', function(t) {
-    var record = {};
-
-    var labelParts = ['initial value'];
-
-    var f = schemas.SGP.regional;
-
-    t.deepEqual(f(record, labelParts), ['initial value']);
-    t.end();
-
-  });
-
-};
-
-module.exports.tests.swe = function(test, common) {
-  test('SWE.local should use neighbourhood value over region, county, localadmin, locality', function(t) {
-    var record = {
-      neighbourhood: 'neighbourhood value',
-      county: 'county value',
-      localadmin: 'localadmin value',
-      locality: 'locality value',
-      region: 'region value'
-    };
-
-    var labelParts = ['initial value'];
-
-    var f = schemas.SWE.local;
-
-    t.deepEqual(f(record, labelParts), ['initial value', 'neighbourhood value']);
-    t.end();
-
-  });
-
-  test('SWE.local should use region value over county, localadmin, locality', function(t) {
-    var record = {
-      county: 'county value',
-      localadmin: 'localadmin value',
-      locality: 'locality value',
-      region: 'region value'
-    };
-
-    var labelParts = ['initial value'];
-
-    var f = schemas.SWE.local;
-
-    t.deepEqual(f(record, labelParts), ['initial value', 'region value']);
-    t.end();
-
-  });
-
-  test('SWE.local should use county value over localadmin, locality', function(t) {
-    var record = {
-      localadmin: 'localadmin value',
-      locality: 'locality value',
-      county: 'county value'
-    };
-
-    var labelParts = ['initial value'];
-
-    var f = schemas.SWE.local;
-
-    t.deepEqual(f(record, labelParts), ['initial value', 'county value']);
-    t.end();
-
-  });
-
-  test('SWE.local should use localadmin value over locality', function(t) {
-    var record = {
-      localadmin: 'localadmin value',
-      locality: 'locality value'
-    };
-
-    var labelParts = ['initial value'];
-
-    var f = schemas.SWE.local;
-
-    t.deepEqual(f(record, labelParts), ['initial value', 'localadmin value']);
-    t.end();
-
-  });
-
-  test('SWE.local should use locality value when nothing else is available', function(t) {
-    var record = {
-      locality: 'locality value'
-    };
-
-    var labelParts = ['initial value'];
-
-    var f = schemas.SWE.local;
-
-    t.deepEqual(f(record, labelParts), ['initial value', 'locality value']);
-    t.end();
-
-  });
-
-  test('SWE.local should not append anything when none of neighbourhood, region, county, localadmin, locality are available', function(t) {
-    var record = {};
-
-    var labelParts = ['initial value'];
-
-    var f = schemas.SWE.local;
-
-    t.deepEqual(f(record, labelParts), ['initial value']);
-    t.end();
-
-  });
-
-  test('SGP.regional should use country when available', function(t) {
-    var record = {
-      country: 'country value',
-      country_a: 'country_a value',
-    };
-
-    var labelParts = ['initial value'];
-
-    var f = schemas.SGP.regional;
-
-    t.deepEqual(f(record, labelParts), ['initial value', 'country value']);
-    t.end();
-
-  });
-
-  test('SGP.regional should not append anything when country is not available', function(t) {
-    var record = {
-      country_a: 'country_a value'
-    };
-
-    var labelParts = ['initial value'];
-
-    var f = schemas.SGP.regional;
-
-    t.deepEqual(f(record, labelParts), ['initial value']);
-    t.end();
-
-  });
-
-};
-
-module.exports.tests.default = function(test, common) {
-  test('default.local should use localadmin value over locality, neighbourhood, county, region', function(t) {
-    var record = {
-      neighbourhood: 'neighbourhood value',
-      county: 'county value',
-      localadmin: 'localadmin value',
-      locality: 'locality value',
-      region: 'region value'
-    };
-
-    var labelParts = ['initial value'];
-
-    var f = schemas.default.local;
-
-    t.deepEqual(f(record, labelParts), ['initial value', 'localadmin value']);
-    t.end();
-
-  });
-
-  test('default.local should use locality value over neighbourhood, county, region', function(t) {
-    var record = {
-      neighbourhood: 'neighbourhood value',
-      county: 'county value',
-      locality: 'locality value',
-      region: 'region value'
-    };
-
-    var labelParts = ['initial value'];
-
-    var f = schemas.default.local;
-
-    t.deepEqual(f(record, labelParts), ['initial value', 'locality value']);
-    t.end();
-
-  });
-
-  test('default.local should use neighbourhood value over county, region', function(t) {
-    var record = {
-      neighbourhood: 'neighbourhood value',
-      county: 'county value',
-      region: 'region value'
-    };
-
-    var labelParts = ['initial value'];
-
-    var f = schemas.default.local;
-
-    t.deepEqual(f(record, labelParts), ['initial value', 'neighbourhood value']);
-    t.end();
-
-  });
-
-  test('default.local should use county value over region', function(t) {
-    var record = {
-      county: 'county value',
-      region: 'region value'
-    };
-
-    var labelParts = ['initial value'];
-
-    var f = schemas.default.local;
-
-    t.deepEqual(f(record, labelParts), ['initial value', 'county value']);
-    t.end();
-
-  });
-
-  test('default.local should use region value when nothing else is available', function(t) {
-    var record = {
-      region: 'region value'
-    };
-
-    var labelParts = ['initial value'];
-
-    var f = schemas.default.local;
-
-    t.deepEqual(f(record, labelParts), ['initial value', 'region value']);
-    t.end();
-
-  });
-
-  test('default.local should not append anything when none of neighbourhood, region, county, localadmin, ' +
-        'locality are available', function(t) {
-    var record = {};
-
-    var labelParts = ['initial value'];
-
-    var f = schemas.default.local;
-
-    t.deepEqual(f(record, labelParts), ['initial value']);
-    t.end();
-
-  });
-
-  test('default.regional should use country over region, region_a, or country_a', function(t) {
-    var record = {
-      region: 'region value',
-      region_a: 'region_a value',
-      country: 'country value',
-      country_a: 'country_a value'
-    };
-
-    var labelParts = ['initial value'];
-
-    var f = schemas.default.regional;
-
-    t.deepEqual(f(record, labelParts), ['initial value', 'country value']);
-    t.end();
-
-  });
-
-  test('default.regional should not append any value if country is not available', function(t) {
-    var record = {
-      region: 'region value',
-      region_a: 'region_a value',
-      country_a: 'country_a value'
-    };
-
-    var labelParts = ['initial value'];
-
-    var f = schemas.default.regional;
-
-    t.deepEqual(f(record, labelParts), ['initial value']);
-    t.end();
-
-  });
-
-};
-
 module.exports.all = function (tape, common) {
 
   function test(name, testFunction) {
diff --git a/test/unit/run.js b/test/unit/run.js
index 2e8b382e..5f2ad49b 100644
--- a/test/unit/run.js
+++ b/test/unit/run.js
@@ -13,10 +13,10 @@ var tests = [
   require('./controller/place'),
   require('./controller/search'),
   require('./helper/geojsonify'),
+  require('./helper/labelGenerator_examples'),
   require('./helper/labelGenerator_default'),
+  require('./helper/labelGenerator_CAN'),
   require('./helper/labelGenerator_GBR'),
-  require('./helper/labelGenerator_SGP'),
-  require('./helper/labelGenerator_SWE'),
   require('./helper/labelGenerator_USA'),
   require('./helper/labelSchema'),
   require('./helper/text_parser'),