public void op_ToString_whenEmptyValues()
{
PostalAddressFileEntry entry = new KeyStringDictionary
{
new KeyStringPair("ORD", string.Empty),
new KeyStringPair("ORC", string.Empty),
new KeyStringPair("SBN", string.Empty),
new KeyStringPair("BNA", string.Empty),
new KeyStringPair("POB", string.Empty),
new KeyStringPair("NUM", string.Empty),
new KeyStringPair("DST", string.Empty),
new KeyStringPair("STM", string.Empty),
new KeyStringPair("DDL", string.Empty),
new KeyStringPair("DLO", string.Empty),
new KeyStringPair("PTN", string.Empty),
new KeyStringPair("PCD", string.Empty),
new KeyStringPair("CTA", string.Empty),
new KeyStringPair("CTP", string.Empty),
new KeyStringPair("CTT", string.Empty),
new KeyStringPair("SCD", string.Empty),
new KeyStringPair("CAT", string.Empty),
new KeyStringPair("NDP", string.Empty),
new KeyStringPair("DPX", string.Empty),
new KeyStringPair("URN", string.Empty),
new KeyStringPair("MOC", string.Empty),
new KeyStringPair("MRC", string.Empty),
new KeyStringPair("UMR", string.Empty),
new KeyStringPair("DTO", string.Empty)
};
const string expected = ",,,,,,,,,,,,,,,,,,,,,,,";
var actual = entry.ToString();
Assert.Equal(expected, actual);
}
public void op_ToString()
{
PostalAddressFileEntry entry = new KeyStringDictionary
{
new KeyStringPair("ORD", "A"),
new KeyStringPair("ORC", "B"),
new KeyStringPair("SBN", "C"),
new KeyStringPair("BNA", "D"),
new KeyStringPair("POB", "E"),
new KeyStringPair("NUM", "F"),
new KeyStringPair("DST", "G"),
new KeyStringPair("STM", "H"),
new KeyStringPair("DDL", "I"),
new KeyStringPair("DLO", "J"),
new KeyStringPair("PTN", "K"),
new KeyStringPair("PCD", "AB10 1AA"),
new KeyStringPair("CTA", "L"),
new KeyStringPair("CTP", "M"),
new KeyStringPair("CTT", "N"),
new KeyStringPair("SCD", "1"),
new KeyStringPair("CAT", "L"),
new KeyStringPair("NDP", "2"),
new KeyStringPair("DPX", "3"),
new KeyStringPair("URN", "4"),
new KeyStringPair("MOC", "5"),
new KeyStringPair("MRC", "6"),
new KeyStringPair("UMR", "7"),
new KeyStringPair("DTO", "P")
};
const string expected = "A,B,C,D,E,F,G,H,I,J,K,AB10 1AA,L,M,N,1,L,2,3,4,5,6,7,P";
var actual = entry.ToString();
Assert.Equal(expected, actual);
}
public static string Line(KeyStringDictionary data,
IList<string> columns)
{
if (null == data)
{
throw new ArgumentNullException("data");
}
if (null == columns)
{
throw new ArgumentNullException("columns");
}
if (0 == columns.Count)
{
throw new ArgumentOutOfRangeException("columns");
}
#if NET20
var values = new List<string>();
foreach (var column in columns)
{
values.Add(data[column.Normalize().Trim()]);
}
#else
var values = columns
.Select(column => data[column.Normalize().Trim()])
.ToList();
#endif
return Line(values);
}
public RecordFile()
{
Headers = new KeyStringDictionary
{
{
"urn", string.Empty
},
{
"key", string.Empty
},
{
"etag", string.Empty
},
{
"created", string.Empty
},
{
"modified", string.Empty
},
{
"cacheability", string.Empty
},
{
"expiration", string.Empty
},
{
"status", string.Empty
}
};
}
public void op_ToMarketingFormat_KeyStringDictionary_emptyBNA()
{
var entry = new KeyStringDictionary
{
{ "SBN", string.Empty },
{ "BNA", string.Empty },
{ "NUM", "123" },
{ "DST", "Little Lane" },
{ "STM", "High Street" },
{ "DDL", "Local Wood" },
{ "DLO", "Wide Area" },
{ "PTN", "Postal Town" },
{ "PCD", "AA1 2ZZ" },
};
var obj = BritishAddress.ToMarketingFormat(entry);
Assert.Equal("123 Little Lane", obj["ADDRESS 1"]);
Assert.Equal("High Street", obj["ADDRESS 2"]);
Assert.Equal("Local Wood", obj["ADDRESS 3"]);
Assert.Equal("Wide Area", obj["ADDRESS 4"]);
Assert.Equal("Postal Town", obj["ADDRESS 5"]);
Assert.Equal(string.Empty, obj["ADDRESS 6"]);
Assert.Equal("AA1 2ZZ", obj["POSTCODE"]);
}
public static string Line(KeyStringDictionary data,
IList <string> columns)
{
if (null == data)
{
throw new ArgumentNullException("data");
}
if (null == columns)
{
throw new ArgumentNullException("columns");
}
if (0 == columns.Count)
{
throw new ArgumentOutOfRangeException("columns");
}
#if NET20
var values = new List <string>();
foreach (var column in columns)
{
values.Add(data[column.Normalize().Trim()]);
}
#else
var values = columns
.Select(column => data[column.Normalize().Trim()])
.ToList();
#endif
return(Line(values));
}
public void opImplicit_PostalAddressFileEntry_KeyStringDictionaryEmpty()
{
PostalAddressFileEntry actual = new KeyStringDictionary();
Assert.Null(actual.Organization.Department);
Assert.Null(actual.Organization.Name);
Assert.Null(actual.Address.SubBuildingName);
Assert.Null(actual.Address.PostOfficeBox);
Assert.Null(actual.Address.BuildingName);
Assert.Null(actual.Address.BuildingNumber);
Assert.Null(actual.Address.DependentStreet);
Assert.Null(actual.Address.MainStreet);
Assert.Null(actual.Address.DoubleDependentLocality);
Assert.Null(actual.Address.DependentLocality);
Assert.Null(actual.Address.PostTown);
Assert.Null(actual.Address.AdministrativeCounty);
Assert.Null(actual.Address.FormerPostalCounty);
Assert.Null(actual.Address.TraditionalCounty);
Assert.Null(actual.Address.Postcode);
Assert.Null(actual.Category);
Assert.Null(actual.DeliveryPointSuffix);
Assert.False(actual.MultipleOccupancyCount.HasValue);
Assert.False(actual.MultipleResidencyRecordCount.HasValue);
Assert.False(actual.NumberOfDeliveryPoints.HasValue);
Assert.False(actual.Origin.HasValue);
Assert.False(actual.SortCode.HasValue);
Assert.False(actual.UniqueDeliveryPointReferenceNumber.HasValue);
Assert.False(actual.UniqueMultipleResidenceReferenceNumber.HasValue);
}
public void op_ToString_whenEmpty()
{
PostalAddressFileEntry entry = new KeyStringDictionary();
const string expected = ",,,,,,,,,,,,,,,,,,,,,,,";
var actual = entry.ToString();
Assert.Equal(expected, actual);
}
public static string Line(KeyStringDictionary data)
{
if (null == data)
{
throw new ArgumentNullException("data");
}
return Line(data.Values);
}
public void ctor_IEqualityComparerOfString()
{
var data = new KeyStringDictionary(StringComparer.Ordinal)
{
{ "NAME", "value" }
};
Assert.Throws<KeyNotFoundException>(() => data["name"]);
}
public string IdentifyShard(KeyStringDictionary entry)
{
if (null == entry)
{
throw new ArgumentNullException("entry");
}
return (entry[Column] ?? string.Empty).Trim();
}
public static string Line(KeyStringDictionary data)
{
if (null == data)
{
throw new ArgumentNullException("data");
}
return(Line(data.Values));
}
public string IdentifyShard(KeyStringDictionary entry)
{
if (null == entry)
{
throw new ArgumentNullException("entry");
}
return((entry[Column] ?? string.Empty).Trim());
}
public void opImplicit_PostalAddressFileEntry_KeyStringDictionaryEmptyValues()
{
PostalAddressFileEntry actual = new KeyStringDictionary
{
new KeyStringPair("ORD", string.Empty),
new KeyStringPair("ORC", string.Empty),
new KeyStringPair("SBN", string.Empty),
new KeyStringPair("BNA", string.Empty),
new KeyStringPair("POB", string.Empty),
new KeyStringPair("NUM", string.Empty),
new KeyStringPair("DST", string.Empty),
new KeyStringPair("STM", string.Empty),
new KeyStringPair("DDL", string.Empty),
new KeyStringPair("DLO", string.Empty),
new KeyStringPair("PTN", string.Empty),
new KeyStringPair("CTA", string.Empty),
new KeyStringPair("CTP", string.Empty),
new KeyStringPair("CTT", string.Empty),
new KeyStringPair("PCD", string.Empty),
new KeyStringPair("SCD", string.Empty),
new KeyStringPair("CAT", string.Empty),
new KeyStringPair("NDP", string.Empty),
new KeyStringPair("DPX", string.Empty),
new KeyStringPair("URN", string.Empty),
new KeyStringPair("MOC", string.Empty),
new KeyStringPair("MRC", string.Empty),
new KeyStringPair("UMR", string.Empty),
new KeyStringPair("DTO", string.Empty)
};
Assert.Equal(string.Empty, actual.Organization.Department);
Assert.Equal(string.Empty, actual.Organization.Name);
Assert.Equal(string.Empty, actual.Address.SubBuildingName);
Assert.Equal(string.Empty, actual.Address.PostOfficeBox);
Assert.Equal(string.Empty, actual.Address.BuildingName);
Assert.Equal(string.Empty, actual.Address.BuildingNumber);
Assert.Equal(string.Empty, actual.Address.DependentStreet);
Assert.Equal(string.Empty, actual.Address.MainStreet);
Assert.Equal(string.Empty, actual.Address.DoubleDependentLocality);
Assert.Equal(string.Empty, actual.Address.DependentLocality);
Assert.Equal(string.Empty, actual.Address.AdministrativeCounty);
Assert.Equal(string.Empty, actual.Address.FormerPostalCounty);
Assert.Equal(string.Empty, actual.Address.TraditionalCounty);
Assert.Equal(string.Empty, actual.Address.PostTown);
Assert.Null(actual.Address.Postcode.Area);
Assert.Null(actual.Category);
Assert.Equal(string.Empty, actual.DeliveryPointSuffix);
Assert.False(actual.MultipleOccupancyCount.HasValue);
Assert.False(actual.MultipleResidencyRecordCount.HasValue);
Assert.False(actual.NumberOfDeliveryPoints.HasValue);
Assert.False(actual.Origin.HasValue);
Assert.False(actual.SortCode.HasValue);
Assert.False(actual.UniqueDeliveryPointReferenceNumber.HasValue);
Assert.False(actual.UniqueMultipleResidenceReferenceNumber.HasValue);
}
public void opImplicit_PostalAddressFileEntry_KeyStringDictionary()
{
PostalAddressFileEntry actual = new KeyStringDictionary
{
new KeyStringPair("ORD", "Department"),
new KeyStringPair("ORC", "Organisation"),
new KeyStringPair("SBN", "Flat A"),
new KeyStringPair("BNA", "Building"),
new KeyStringPair("POB", "PO Box 123"),
new KeyStringPair("NUM", "1"),
new KeyStringPair("DST", "Little Close"),
new KeyStringPair("STM", "High Street"),
new KeyStringPair("DDL", "Village"),
new KeyStringPair("DLO", "Locality"),
new KeyStringPair("PTN", "Town"),
new KeyStringPair("CTA", "Countyshire"),
new KeyStringPair("CTP", "Postalshire"),
new KeyStringPair("CTT", "Oldshire"),
new KeyStringPair("PCD", "AB10 1AA"),
new KeyStringPair("SCD", "12345"),
new KeyStringPair("CAT", "L"),
new KeyStringPair("NDP", "12"),
new KeyStringPair("DPX", "1A8"),
new KeyStringPair("URN", "123456789"),
new KeyStringPair("MOC", "9999"),
new KeyStringPair("MRC", "9876"),
new KeyStringPair("UMR", "987654321"),
new KeyStringPair("DTO", "P")
};
Assert.Equal("Department", actual.Organization.Department);
Assert.Equal("Organisation", actual.Organization.Name);
Assert.Equal("Flat A", actual.Address.SubBuildingName);
Assert.Equal("PO Box 123", actual.Address.PostOfficeBox);
Assert.Equal("Building", actual.Address.BuildingName);
Assert.Equal("1", actual.Address.BuildingNumber);
Assert.Equal("Little Close", actual.Address.DependentStreet);
Assert.Equal("High Street", actual.Address.MainStreet);
Assert.Equal("Village", actual.Address.DoubleDependentLocality);
Assert.Equal("Locality", actual.Address.DependentLocality);
Assert.Equal("Town", actual.Address.PostTown);
Assert.Equal("Countyshire", actual.Address.AdministrativeCounty);
Assert.Equal("Postalshire", actual.Address.FormerPostalCounty);
Assert.Equal("Oldshire", actual.Address.TraditionalCounty);
Assert.Equal("AB10 1AA", actual.Address.Postcode.Unit);
Assert.IsType <LargeUserCategory>(actual.Category);
Assert.Equal("1A8", actual.DeliveryPointSuffix);
Assert.Equal(9999, actual.MultipleOccupancyCount);
Assert.Equal(9876, actual.MultipleResidencyRecordCount);
Assert.Equal(12, actual.NumberOfDeliveryPoints);
Assert.Equal('P', actual.Origin);
Assert.Equal(12345, actual.SortCode);
Assert.Equal(123456789, actual.UniqueDeliveryPointReferenceNumber);
Assert.Equal(987654321, actual.UniqueMultipleResidenceReferenceNumber);
}
public void opImplicit_PostalAddressFileEntry_KeyStringDictionary()
{
PostalAddressFileEntry actual = new KeyStringDictionary
{
new KeyStringPair("ORD", "Department"),
new KeyStringPair("ORC", "Organisation"),
new KeyStringPair("SBN", "Flat A"),
new KeyStringPair("BNA", "Building"),
new KeyStringPair("POB", "PO Box 123"),
new KeyStringPair("NUM", "1"),
new KeyStringPair("DST", "Little Close"),
new KeyStringPair("STM", "High Street"),
new KeyStringPair("DDL", "Village"),
new KeyStringPair("DLO", "Locality"),
new KeyStringPair("PTN", "Town"),
new KeyStringPair("CTA", "Countyshire"),
new KeyStringPair("CTP", "Postalshire"),
new KeyStringPair("CTT", "Oldshire"),
new KeyStringPair("PCD", "AB10 1AA"),
new KeyStringPair("SCD", "12345"),
new KeyStringPair("CAT", "L"),
new KeyStringPair("NDP", "12"),
new KeyStringPair("DPX", "1A8"),
new KeyStringPair("URN", "123456789"),
new KeyStringPair("MOC", "9999"),
new KeyStringPair("MRC", "9876"),
new KeyStringPair("UMR", "987654321"),
new KeyStringPair("DTO", "P")
};
Assert.Equal("Department", actual.Organization.Department);
Assert.Equal("Organisation", actual.Organization.Name);
Assert.Equal("Flat A", actual.Address.SubBuildingName);
Assert.Equal("PO Box 123", actual.Address.PostOfficeBox);
Assert.Equal("Building", actual.Address.BuildingName);
Assert.Equal("1", actual.Address.BuildingNumber);
Assert.Equal("Little Close", actual.Address.DependentStreet);
Assert.Equal("High Street", actual.Address.MainStreet);
Assert.Equal("Village", actual.Address.DoubleDependentLocality);
Assert.Equal("Locality", actual.Address.DependentLocality);
Assert.Equal("Town", actual.Address.PostTown);
Assert.Equal("Countyshire", actual.Address.AdministrativeCounty);
Assert.Equal("Postalshire", actual.Address.FormerPostalCounty);
Assert.Equal("Oldshire", actual.Address.TraditionalCounty);
Assert.Equal("AB10 1AA", actual.Address.Postcode.Unit);
Assert.IsType<LargeUserCategory>(actual.Category);
Assert.Equal("1A8", actual.DeliveryPointSuffix);
Assert.Equal(9999, actual.MultipleOccupancyCount);
Assert.Equal(9876, actual.MultipleResidencyRecordCount);
Assert.Equal(12, actual.NumberOfDeliveryPoints);
Assert.Equal('P', actual.Origin);
Assert.Equal(12345, actual.SortCode);
Assert.Equal(123456789, actual.UniqueDeliveryPointReferenceNumber);
Assert.Equal(987654321, actual.UniqueMultipleResidenceReferenceNumber);
}
public void op_IdentifyShard_KeyStringDictionary_whenColumnMissing()
{
const string expected = "value";
var obj = new ShardByValue("foo");
var entry = new KeyStringDictionary
{
{ "bar", expected }
};
Assert.Throws <KeyNotFoundException>(() => obj.IdentifyShard(entry));
}
public void op_IdentifyShard_KeyStringDictionary_whenColumnMissing()
{
const string expected = "value";
var obj = new ShardByValue("foo");
var entry = new KeyStringDictionary
{
{ "bar", expected }
};
Assert.Throws<KeyNotFoundException>(() => obj.IdentifyShard(entry));
}
private static int?TryInt32(KeyStringDictionary data,
string key)
{
if (!data.ContainsKey(key))
{
return(new int?());
}
return(string.IsNullOrEmpty(data[key])
? new int?()
: data.TryValue <int>(key));
}
public void op_Line_KeyStringDictionary()
{
var obj = new KeyStringDictionary
{
new KeyStringPair("A", "123"),
new KeyStringPair("B", "XYZ")
};
const string expected = "123\tXYZ";
var actual = Tsv.Line(obj);
Assert.Equal(expected, actual);
}
public void op_Line_KeyStringDictionary_whenEmptyValue()
{
var obj = new KeyStringDictionary
{
new KeyStringPair("A", string.Empty),
new KeyStringPair("B", "XYZ")
};
const string expected = "\tXYZ";
var actual = Tsv.Line(obj);
Assert.Equal(expected, actual);
}
public void op_Header_KeyStringDictionary()
{
var obj = new KeyStringDictionary
{
new KeyStringPair("A", string.Empty),
new KeyStringPair("B", string.Empty)
};
const string expected = "A\tB";
var actual = Tsv.Header(obj);
Assert.Equal(expected, actual);
}
public void indexer_int()
{
var obj = new KeyStringDictionary
{
new KeyStringPair("zero", "0"),
new KeyStringPair("one", "1")
};
for (var i = 0; i < obj.Count; i++)
{
Assert.Equal(XmlConvert.ToString(i), obj[i]);
}
}
public void op_Header_KeyStringDictionary_whenEmptyValue()
{
var obj = new KeyStringDictionary
{
new KeyStringPair(string.Empty, "x"),
new KeyStringPair("ABC", "x")
};
const string expected = "\tABC";
var actual = Tsv.Header(obj);
Assert.Equal(expected, actual);
}
public void ctor()
{
const string expected = "value";
var data = new KeyStringDictionary
{
{ "NAME", expected }
};
var actual = data["name"];
Assert.Equal(expected, actual);
}
public void op_IdentifyShard_KeyStringDictionary(string expected,
string value)
{
var obj = new ShardByValue("example");
var entry = new KeyStringDictionary
{
{ "example", value }
};
var actual = obj.IdentifyShard(entry);
Assert.Equal(expected, actual);
}
public void op_IdentifyShard_KeyStringDictionary(string expected,
string value)
{
var obj = new ShardByValue("example");
var entry = new KeyStringDictionary
{
{ "example", value }
};
var actual = obj.IdentifyShard(entry);
Assert.Equal(expected, actual);
}
public void op_Line_KeyStringDictionary_IListOfString()
{
var obj = new KeyStringDictionary
{
new KeyStringPair("A", "123"),
new KeyStringPair("B", "ignore"),
new KeyStringPair("C", "XYZ")
};
const string expected = "123\tXYZ";
var actual = Tsv.Line(obj, "A|C".Split('|').ToList());
Assert.Equal(expected, actual);
}
public void op_Line_KeyStringDictionary_IListOfString()
{
var obj = new KeyStringDictionary
{
new KeyStringPair("A", "123"),
new KeyStringPair("B", "ignore"),
new KeyStringPair("C", "left,right")
};
const string expected = "123,\"left,right\"";
var actual = Csv.Line(obj, "A,C".Split(',').ToList());
Assert.Equal(expected, actual);
}
public void op_Line_KeyStringDictionary()
{
var obj = new KeyStringDictionary
{
new KeyStringPair("A", "123"),
new KeyStringPair("B", "left,right"),
new KeyStringPair("C", "a \"b\" c"),
};
const string expected = "123,\"left,right\",\"a \"\"b\"\" c\"";
var actual = Csv.Line(obj);
Assert.Equal(expected, actual);
}
public static BritishTelephoneNumberPlanItem Load(KeyStringDictionary entry)
{
if (null == entry)
{
throw new ArgumentNullException("entry");
}
var dialing = "{0}{1}".FormatWith(entry["Code"], entry["D/DE"]);
string area;
if (dialing.StartsWith("2", StringComparison.Ordinal))
{
area = dialing.Substring(0, 2);
}
else if (dialing.Substring(0, 3).In("113", "114", "115", "116", "117", "118", "121", "131", "141", "151", "161", "191"))
{
area = dialing.Substring(0, 3);
}
else
{
switch (entry["Notes"])
{
case "3 Digit Area Code":
case "3 Digit Code Area":
area = dialing.Substring(0, 3);
break;
case "4 Digit Code Area":
area = dialing.Substring(0, 4);
break;
case "5 Digit Code Area":
area = dialing.Substring(0, 5);
break;
default:
area = dialing;
break;
}
}
return(new BritishTelephoneNumberPlanItem
{
AreaCode = area,
DialingCode = dialing,
Use = entry["Use"],
});
}
public void op_Load_KeyStringDictionary_whenHarrogate()
{
var entry = new KeyStringDictionary
{
{ "Code", "1423" },
{ "D/DE", "6" },
{ "Notes", "ELNS" },
{ "Use", "Harrogate" },
};
var actual = BritishTelephoneNumberPlan.Load(entry);
Assert.Equal("14236", actual.AreaCode);
Assert.Equal("14236", actual.DialingCode);
Assert.Equal("Harrogate", actual.Use);
}
public void op_Load_KeyStringDictionary_whenLancaster()
{
var entry = new KeyStringDictionary
{
{ "Code", "1524" },
{ "D/DE", "5" },
{ "Notes", "4 Digit Code Area" },
{ "Use", "Lancaster" },
};
var actual = BritishTelephoneNumberPlan.Load(entry);
Assert.Equal("1524", actual.AreaCode);
Assert.Equal("15245", actual.DialingCode);
Assert.Equal("Lancaster", actual.Use);
}
public void op_Load_KeyStringDictionary_whenLondon()
{
var entry = new KeyStringDictionary
{
{ "Code", "2071" },
{ "D/DE", string.Empty },
{ "Notes", string.Empty },
{ "Use", "London" },
};
var actual = BritishTelephoneNumberPlan.Load(entry);
Assert.Equal("20", actual.AreaCode);
Assert.Equal("2071", actual.DialingCode);
Assert.Equal("London", actual.Use);
}
public void op_Load_KeyStringDictionary_whenGlasgow()
{
var entry = new KeyStringDictionary
{
{ "Code", "1412" },
{ "D/DE", string.Empty },
{ "Notes", "3 Digit Code Area" },
{ "Use", "Glasgow" },
};
var actual = BritishTelephoneNumberPlan.Load(entry);
Assert.Equal("141", actual.AreaCode);
Assert.Equal("1412", actual.DialingCode);
Assert.Equal("Glasgow", actual.Use);
}
public void op_Load_KeyStringDictionary_whenNottingham()
{
var entry = new KeyStringDictionary
{
{ "Code", "1152" },
{ "D/DE", "0" },
{ "Notes", "3 Digit Area Code" },
{ "Use", "Nottingham" },
};
var actual = BritishTelephoneNumberPlan.Load(entry);
Assert.Equal("115", actual.AreaCode);
Assert.Equal("11520", actual.DialingCode);
Assert.Equal("Nottingham", actual.Use);
}
public void op_Load_KeyStringDictionary_whenSedbergh()
{
var entry = new KeyStringDictionary
{
{ "Code", "1539" },
{ "D/DE", "6" },
{ "Notes", "5 Digit Code Area" },
{ "Use", "Sedbergh" },
};
var actual = BritishTelephoneNumberPlan.Load(entry);
Assert.Equal("15396", actual.AreaCode);
Assert.Equal("15396", actual.DialingCode);
Assert.Equal("Sedbergh", actual.Use);
}
public void op_Load_KeyStringDictionary_when3DigitAreaCode()
{
var entry = new KeyStringDictionary
{
{ "Code", "1999" },
{ "D/DE", string.Empty },
{ "Notes", "3 Digit Area Code" },
{ "Use", "Example" },
};
var actual = BritishTelephoneNumberPlan.Load(entry);
Assert.Equal("199", actual.AreaCode);
Assert.Equal("1999", actual.DialingCode);
Assert.Equal("Example", actual.Use);
}
public void op_Load_KeyStringDictionary_whenColchester()
{
var entry = new KeyStringDictionary
{
{ "Code", "1206" },
{ "D/DE", string.Empty },
{ "Notes", string.Empty },
{ "Use", "Colchester" },
};
var actual = BritishTelephoneNumberPlan.Load(entry);
Assert.Equal("1206", actual.AreaCode);
Assert.Equal("1206", actual.DialingCode);
Assert.Equal("Colchester", actual.Use);
}
private MarketingAddress AddColumns(KeyStringDictionary source,
MarketingAddress destination)
{
foreach (var column in Columns)
{
destination[column] = source[column];
}
if (null != References)
{
destination["REFERENCE"] = References[source["KEY"]];
}
return(destination);
}
public void op_IdentifyShard_KeyStringDictionary()
{
var entry = new KeyStringDictionary();
const string expected = "example";
var mock = new Mock<IIdentifyShard>();
mock
.Setup(x => x.IdentifyShard(entry))
.Returns(expected)
.Verifiable();
var actual = mock.Object.IdentifyShard(entry);
Assert.Equal(expected, actual);
mock.VerifyAll();
}
public static PostalAddressFileEntry FromKeyStringDictionary(KeyStringDictionary data)
{
if (null == data)
{
return null;
}
var result = new PostalAddressFileEntry
{
Address =
{
SubBuildingName = TryString(data, "SBN"),
PostOfficeBox = TryString(data, "POB"),
BuildingName = TryString(data, "BNA"),
BuildingNumber = TryString(data, "NUM"),
DependentStreet = TryString(data, "DST"),
MainStreet = TryString(data, "STM"),
DoubleDependentLocality = TryString(data, "DDL"),
DependentLocality = TryString(data, "DLO"),
PostTown = TryString(data, "PTN"),
AdministrativeCounty = TryString(data, "CTA"),
FormerPostalCounty = TryString(data, "CTP"),
TraditionalCounty = TryString(data, "CTT"),
Postcode = TryString(data, "PCD")
},
Organization =
{
Department = TryString(data, "ORD"),
Name = TryString(data, "ORC")
},
Category = data.ContainsKey("CAT") && !string.IsNullOrEmpty(data["CAT"]) ? UserCategory.Resolve(data["CAT"][0]) : null,
DeliveryPointSuffix = TryString(data, "DPX"),
MultipleOccupancyCount = TryInt32(data, "MOC"),
MultipleResidencyRecordCount = TryInt32(data, "MRC"),
NumberOfDeliveryPoints = TryInt32(data, "NDP"),
Origin = data.ContainsKey("DTO") && !string.IsNullOrEmpty(data["DTO"]) ? data["DTO"][0] : new char?(),
SortCode = TryInt32(data, "SCD"),
UniqueMultipleResidenceReferenceNumber = TryInt32(data, "UMR"),
UniqueDeliveryPointReferenceNumber = TryInt32(data, "URN"),
};
return result;
}
public void ctor_SerializationInfo_StreamingContext()
{
var expected = new KeyStringDictionary
{
new KeyStringPair("key", "value")
};
KeyStringDictionary actual;
using (Stream stream = new MemoryStream())
{
var formatter = new BinaryFormatter();
var obj = new KeyStringDictionary
{
new KeyStringPair("key", "value")
};
formatter.Serialize(stream, obj);
stream.Position = 0;
actual = (KeyStringDictionary)formatter.Deserialize(stream);
}
Assert.Equal(expected, actual);
}
public void op_ToString_whenEmptyValues()
{
PostalAddressFileEntry entry = new KeyStringDictionary
{
new KeyStringPair("ORD", string.Empty),
new KeyStringPair("ORC", string.Empty),
new KeyStringPair("SBN", string.Empty),
new KeyStringPair("BNA", string.Empty),
new KeyStringPair("POB", string.Empty),
new KeyStringPair("NUM", string.Empty),
new KeyStringPair("DST", string.Empty),
new KeyStringPair("STM", string.Empty),
new KeyStringPair("DDL", string.Empty),
new KeyStringPair("DLO", string.Empty),
new KeyStringPair("PTN", string.Empty),
new KeyStringPair("PCD", string.Empty),
new KeyStringPair("CTA", string.Empty),
new KeyStringPair("CTP", string.Empty),
new KeyStringPair("CTT", string.Empty),
new KeyStringPair("SCD", string.Empty),
new KeyStringPair("CAT", string.Empty),
new KeyStringPair("NDP", string.Empty),
new KeyStringPair("DPX", string.Empty),
new KeyStringPair("URN", string.Empty),
new KeyStringPair("MOC", string.Empty),
new KeyStringPair("MRC", string.Empty),
new KeyStringPair("UMR", string.Empty),
new KeyStringPair("DTO", string.Empty)
};
const string expected = ",,,,,,,,,,,,,,,,,,,,,,,";
var actual = entry.ToString();
Assert.Equal(expected, actual);
}
public void op_ToString_whenEmpty()
{
PostalAddressFileEntry entry = new KeyStringDictionary();
const string expected = ",,,,,,,,,,,,,,,,,,,,,,,";
var actual = entry.ToString();
Assert.Equal(expected, actual);
}
public void op_ToString()
{
PostalAddressFileEntry entry = new KeyStringDictionary
{
new KeyStringPair("ORD", "A"),
new KeyStringPair("ORC", "B"),
new KeyStringPair("SBN", "C"),
new KeyStringPair("BNA", "D"),
new KeyStringPair("POB", "E"),
new KeyStringPair("NUM", "F"),
new KeyStringPair("DST", "G"),
new KeyStringPair("STM", "H"),
new KeyStringPair("DDL", "I"),
new KeyStringPair("DLO", "J"),
new KeyStringPair("PTN", "K"),
new KeyStringPair("PCD", "AB10 1AA"),
new KeyStringPair("CTA", "L"),
new KeyStringPair("CTP", "M"),
new KeyStringPair("CTT", "N"),
new KeyStringPair("SCD", "1"),
new KeyStringPair("CAT", "L"),
new KeyStringPair("NDP", "2"),
new KeyStringPair("DPX", "3"),
new KeyStringPair("URN", "4"),
new KeyStringPair("MOC", "5"),
new KeyStringPair("MRC", "6"),
new KeyStringPair("UMR", "7"),
new KeyStringPair("DTO", "P")
};
const string expected = "A,B,C,D,E,F,G,H,I,J,K,AB10 1AA,L,M,N,1,L,2,3,4,5,6,7,P";
var actual = entry.ToString();
Assert.Equal(expected, actual);
}
public void opImplicit_PostalAddressFileEntry_KeyStringDictionaryEmptyValues()
{
PostalAddressFileEntry actual = new KeyStringDictionary
{
new KeyStringPair("ORD", string.Empty),
new KeyStringPair("ORC", string.Empty),
new KeyStringPair("SBN", string.Empty),
new KeyStringPair("BNA", string.Empty),
new KeyStringPair("POB", string.Empty),
new KeyStringPair("NUM", string.Empty),
new KeyStringPair("DST", string.Empty),
new KeyStringPair("STM", string.Empty),
new KeyStringPair("DDL", string.Empty),
new KeyStringPair("DLO", string.Empty),
new KeyStringPair("PTN", string.Empty),
new KeyStringPair("CTA", string.Empty),
new KeyStringPair("CTP", string.Empty),
new KeyStringPair("CTT", string.Empty),
new KeyStringPair("PCD", string.Empty),
new KeyStringPair("SCD", string.Empty),
new KeyStringPair("CAT", string.Empty),
new KeyStringPair("NDP", string.Empty),
new KeyStringPair("DPX", string.Empty),
new KeyStringPair("URN", string.Empty),
new KeyStringPair("MOC", string.Empty),
new KeyStringPair("MRC", string.Empty),
new KeyStringPair("UMR", string.Empty),
new KeyStringPair("DTO", string.Empty)
};
Assert.Equal(string.Empty, actual.Organization.Department);
Assert.Equal(string.Empty, actual.Organization.Name);
Assert.Equal(string.Empty, actual.Address.SubBuildingName);
Assert.Equal(string.Empty, actual.Address.PostOfficeBox);
Assert.Equal(string.Empty, actual.Address.BuildingName);
Assert.Equal(string.Empty, actual.Address.BuildingNumber);
Assert.Equal(string.Empty, actual.Address.DependentStreet);
Assert.Equal(string.Empty, actual.Address.MainStreet);
Assert.Equal(string.Empty, actual.Address.DoubleDependentLocality);
Assert.Equal(string.Empty, actual.Address.DependentLocality);
Assert.Equal(string.Empty, actual.Address.AdministrativeCounty);
Assert.Equal(string.Empty, actual.Address.FormerPostalCounty);
Assert.Equal(string.Empty, actual.Address.TraditionalCounty);
Assert.Equal(string.Empty, actual.Address.PostTown);
Assert.Null(actual.Address.Postcode.Area);
Assert.Null(actual.Category);
Assert.Equal(string.Empty, actual.DeliveryPointSuffix);
Assert.False(actual.MultipleOccupancyCount.HasValue);
Assert.False(actual.MultipleResidencyRecordCount.HasValue);
Assert.False(actual.NumberOfDeliveryPoints.HasValue);
Assert.False(actual.Origin.HasValue);
Assert.False(actual.SortCode.HasValue);
Assert.False(actual.UniqueDeliveryPointReferenceNumber.HasValue);
Assert.False(actual.UniqueMultipleResidenceReferenceNumber.HasValue);
}
public void op_Load_KeyStringDictionary_whenLancaster()
{
var entry = new KeyStringDictionary
{
{ "Code", "1524" },
{ "D/DE", "5" },
{ "Notes", "4 Digit Code Area" },
{ "Use", "Lancaster" },
};
var actual = BritishTelephoneNumberPlan.Load(entry);
Assert.Equal("1524", actual.AreaCode);
Assert.Equal("15245", actual.DialingCode);
Assert.Equal("Lancaster", actual.Use);
}
private static int? TryInt32(KeyStringDictionary data,
string key)
{
if (!data.ContainsKey(key))
{
return new int?();
}
return string.IsNullOrEmpty(data[key])
? new int?()
: data.TryValue<int>(key);
}
public void op_Load_KeyStringDictionary_whenGlasgow()
{
var entry = new KeyStringDictionary
{
{ "Code", "1412" },
{ "D/DE", string.Empty },
{ "Notes", "3 Digit Code Area" },
{ "Use", "Glasgow" },
};
var actual = BritishTelephoneNumberPlan.Load(entry);
Assert.Equal("141", actual.AreaCode);
Assert.Equal("1412", actual.DialingCode);
Assert.Equal("Glasgow", actual.Use);
}
public void op_Load_KeyStringDictionary_when3DigitAreaCode()
{
var entry = new KeyStringDictionary
{
{ "Code", "1999" },
{ "D/DE", string.Empty },
{ "Notes", "3 Digit Area Code" },
{ "Use", "Example" },
};
var actual = BritishTelephoneNumberPlan.Load(entry);
Assert.Equal("199", actual.AreaCode);
Assert.Equal("1999", actual.DialingCode);
Assert.Equal("Example", actual.Use);
}
public void opImplicit_PostalAddressFileEntry_KeyStringDictionaryEmpty()
{
PostalAddressFileEntry actual = new KeyStringDictionary();
Assert.Null(actual.Organization.Department);
Assert.Null(actual.Organization.Name);
Assert.Null(actual.Address.SubBuildingName);
Assert.Null(actual.Address.PostOfficeBox);
Assert.Null(actual.Address.BuildingName);
Assert.Null(actual.Address.BuildingNumber);
Assert.Null(actual.Address.DependentStreet);
Assert.Null(actual.Address.MainStreet);
Assert.Null(actual.Address.DoubleDependentLocality);
Assert.Null(actual.Address.DependentLocality);
Assert.Null(actual.Address.PostTown);
Assert.Null(actual.Address.AdministrativeCounty);
Assert.Null(actual.Address.FormerPostalCounty);
Assert.Null(actual.Address.TraditionalCounty);
Assert.Null(actual.Address.Postcode);
Assert.Null(actual.Category);
Assert.Null(actual.DeliveryPointSuffix);
Assert.False(actual.MultipleOccupancyCount.HasValue);
Assert.False(actual.MultipleResidencyRecordCount.HasValue);
Assert.False(actual.NumberOfDeliveryPoints.HasValue);
Assert.False(actual.Origin.HasValue);
Assert.False(actual.SortCode.HasValue);
Assert.False(actual.UniqueDeliveryPointReferenceNumber.HasValue);
Assert.False(actual.UniqueMultipleResidenceReferenceNumber.HasValue);
}
public void op_Load_KeyStringDictionary_whenColchester()
{
var entry = new KeyStringDictionary
{
{ "Code", "1206" },
{ "D/DE", string.Empty },
{ "Notes", string.Empty },
{ "Use", "Colchester" },
};
var actual = BritishTelephoneNumberPlan.Load(entry);
Assert.Equal("1206", actual.AreaCode);
Assert.Equal("1206", actual.DialingCode);
Assert.Equal("Colchester", actual.Use);
}
public void op_ToMarketingFormat_KeyStringDictionary_emptyPTN()
{
var entry = new KeyStringDictionary
{
{ "SBN", string.Empty },
{ "BNA", string.Empty },
{ "NUM", string.Empty },
{ "DST", string.Empty },
{ "STM", string.Empty },
{ "DDL", string.Empty },
{ "DLO", string.Empty },
{ "PTN", string.Empty },
{ "PCD", "AA1 2ZZ" },
};
var obj = BritishAddress.ToMarketingFormat(entry);
Assert.Equal(string.Empty, obj["ADDRESS 1"]);
Assert.Equal(string.Empty, obj["ADDRESS 2"]);
Assert.Equal(string.Empty, obj["ADDRESS 3"]);
Assert.Equal(string.Empty, obj["ADDRESS 4"]);
Assert.Equal(string.Empty, obj["ADDRESS 5"]);
Assert.Equal(string.Empty, obj["ADDRESS 6"]);
Assert.Equal("AA1 2ZZ", obj["POSTCODE"]);
}
public void op_Load_KeyStringDictionary_whenNottingham()
{
var entry = new KeyStringDictionary
{
{ "Code", "1152" },
{ "D/DE", "0" },
{ "Notes", "3 Digit Area Code" },
{ "Use", "Nottingham" },
};
var actual = BritishTelephoneNumberPlan.Load(entry);
Assert.Equal("115", actual.AreaCode);
Assert.Equal("11520", actual.DialingCode);
Assert.Equal("Nottingham", actual.Use);
}
public void op_Load_KeyStringDictionary_whenSedbergh()
{
var entry = new KeyStringDictionary
{
{ "Code", "1539" },
{ "D/DE", "6" },
{ "Notes", "5 Digit Code Area" },
{ "Use", "Sedbergh" },
};
var actual = BritishTelephoneNumberPlan.Load(entry);
Assert.Equal("15396", actual.AreaCode);
Assert.Equal("15396", actual.DialingCode);
Assert.Equal("Sedbergh", actual.Use);
}
public void op_Load_KeyStringDictionary_whenHarrogate()
{
var entry = new KeyStringDictionary
{
{ "Code", "1423" },
{ "D/DE", "6" },
{ "Notes", "ELNS" },
{ "Use", "Harrogate" },
};
var actual = BritishTelephoneNumberPlan.Load(entry);
Assert.Equal("14236", actual.AreaCode);
Assert.Equal("14236", actual.DialingCode);
Assert.Equal("Harrogate", actual.Use);
}
public void op_Load_KeyStringDictionary_whenLondon()
{
var entry = new KeyStringDictionary
{
{ "Code", "2071" },
{ "D/DE", string.Empty },
{ "Notes", string.Empty },
{ "Use", "London" },
};
var actual = BritishTelephoneNumberPlan.Load(entry);
Assert.Equal("20", actual.AreaCode);
Assert.Equal("2071", actual.DialingCode);
Assert.Equal("London", actual.Use);
}
