/// <summary>Assert MapWritable does not grow across calls to readFields.</summary> /// <exception cref="System.Exception"/> /// <seealso><a href="https://issues.apache.org/jira/browse/HADOOP-2244">HADOOP-2244</a> /// </seealso> public virtual void TestMultipleCallsToReadFieldsAreSafe() { // Create an instance and add a key/value. MapWritable m = new MapWritable(); Text t = new Text(GetName()); m[t] = t; // Get current size of map. Key values are 't'. int count = m.Count; // Now serialize... save off the bytes. ByteArrayOutputStream baos = new ByteArrayOutputStream(); DataOutputStream dos = new DataOutputStream(baos); m.Write(dos); dos.Close(); // Now add new values to the MapWritable. m[new Text("key1")] = new Text("value1"); m[new Text("key2")] = new Text("value2"); // Now deserialize the original MapWritable. Ensure count and key values // match original state. ByteArrayInputStream bais = new ByteArrayInputStream(baos.ToByteArray()); DataInputStream dis = new DataInputStream(bais); m.ReadFields(dis); Assert.Equal(count, m.Count); Assert.True(m[t].Equals(t)); dis.Close(); }
/// <summary>Test that number of "unknown" classes is propagated across multiple copies. /// </summary> public virtual void TestForeignClass() { MapWritable inMap = new MapWritable(); inMap[new Text("key")] = new UTF8("value"); inMap[new Text("key2")] = new UTF8("value2"); MapWritable outMap = new MapWritable(inMap); MapWritable copyOfCopy = new MapWritable(outMap); Assert.Equal(1, copyOfCopy.GetNewClasses()); }
/// <summary>the test</summary> public virtual void TestMapWritable() { Text[] keys = new Text[] { new Text("key1"), new Text("key2"), new Text("Key3") }; BytesWritable[] values = new BytesWritable[] { new BytesWritable(Runtime.GetBytesForString ("value1")), new BytesWritable(Runtime.GetBytesForString("value2")), new BytesWritable(Runtime.GetBytesForString("value3")) }; MapWritable inMap = new MapWritable(); for (int i = 0; i < keys.Length; i++) { inMap[keys[i]] = values[i]; } MapWritable outMap = new MapWritable(inMap); Assert.Equal(inMap.Count, outMap.Count); foreach (KeyValuePair <Writable, Writable> e in inMap) { Assert.True(outMap.Contains(e.Key)); Assert.Equal(0, ((WritableComparable)outMap[e.Key]).CompareTo( e.Value)); } // Now for something a little harder... Text[] maps = new Text[] { new Text("map1"), new Text("map2") }; MapWritable mapOfMaps = new MapWritable(); mapOfMaps[maps[0]] = inMap; mapOfMaps[maps[1]] = outMap; MapWritable copyOfMapOfMaps = new MapWritable(mapOfMaps); for (int i_1 = 0; i_1 < maps.Length; i_1++) { Assert.True(copyOfMapOfMaps.Contains(maps[i_1])); MapWritable a = (MapWritable)mapOfMaps[maps[i_1]]; MapWritable b = (MapWritable)copyOfMapOfMaps[maps[i_1]]; Assert.Equal(a.Count, b.Count); foreach (Writable key in a.Keys) { Assert.True(b.Contains(key)); // This will work because we know what we put into each set WritableComparable aValue = (WritableComparable)a[key]; WritableComparable bValue = (WritableComparable)b[key]; Assert.Equal(0, aValue.CompareTo(bValue)); } } }
public virtual void TestEquality() { MapWritable map1 = new MapWritable(); MapWritable map2 = new MapWritable(); MapWritable map3 = new MapWritable(); IntWritable k1 = new IntWritable(5); IntWritable k2 = new IntWritable(10); Text value = new Text("value"); map1[k1] = value; // equal map2[k1] = value; // equal map3[k2] = value; // not equal Assert.True(map1.Equals(map2)); Assert.True(map2.Equals(map1)); NUnit.Framework.Assert.IsFalse(map1.Equals(map3)); Assert.Equal(map1.GetHashCode(), map2.GetHashCode()); NUnit.Framework.Assert.IsFalse(map1.GetHashCode() == map3.GetHashCode()); }