public virtual void TestMany() { //Write a big set of data, one of each primitive type array foreach (object x in bigSet) { //write each test object two ways //First, transparently via ObjectWritable ObjectWritable.WriteObject(@out, x, x.GetType(), null, true); //Second, explicitly via ArrayPrimitiveWritable (new ArrayPrimitiveWritable(x)).Write(@out); } //Now read the data back in @in.Reset(@out.GetData(), @out.GetLength()); for (int x_1 = 0; x_1 < resultSet.Length;) { //First, transparently resultSet[x_1++] = ObjectWritable.ReadObject(@in, null); //Second, explicitly ArrayPrimitiveWritable apw = new ArrayPrimitiveWritable(); apw.ReadFields(@in); resultSet[x_1++] = apw.Get(); } //validate data structures and values Assert.Equal(expectedResultSet.Length, resultSet.Length); for (int x_2 = 0; x_2 < resultSet.Length; x_2++) { Assert.Equal("ComponentType of array " + x_2, expectedResultSet [x_2].GetType().GetElementType(), resultSet[x_2].GetType().GetElementType()); } Assert.True("In and Out arrays didn't match values", Arrays.DeepEquals (expectedResultSet, resultSet)); }
/// <exception cref="System.IO.IOException"/> public virtual void TestSerializeAndDeserializeNull() { bool gotException = false; try { new EnumSetWritable <TestEnumSetWritable.TestEnumSet>(null); } catch (RuntimeException) { gotException = true; } Assert.True("Instantiation of empty EnumSetWritable with no element type class " + "provided should throw exception", gotException); EnumSetWritable <TestEnumSetWritable.TestEnumSet> nullFlagWritable = new EnumSetWritable <TestEnumSetWritable.TestEnumSet>(null, typeof(TestEnumSetWritable.TestEnumSet)); DataOutputBuffer @out = new DataOutputBuffer(); ObjectWritable.WriteObject(@out, nullFlagWritable, nullFlagWritable.GetType(), null ); DataInputBuffer @in = new DataInputBuffer(); @in.Reset(@out.GetData(), @out.GetLength()); EnumSet <TestEnumSetWritable.TestEnumSet> read = ((EnumSetWritable <TestEnumSetWritable.TestEnumSet >)ObjectWritable.ReadObject(@in, null)).Get(); Assert.Equal(read, null); }
public virtual void TestOldFormat() { //Make sure we still correctly write the old format if desired. //Write the data array with old ObjectWritable API //which will set allowCompactArrays false. ObjectWritable.WriteObject(@out, i, i.GetType(), null); //Get ready to read it back @in.Reset(@out.GetData(), @out.GetLength()); //Read the int[] object as written by ObjectWritable, but //"going around" ObjectWritable string className = UTF8.ReadString(@in); Assert.Equal("The int[] written by ObjectWritable as a non-compact array " + "was not labelled as an array of int", i.GetType().FullName, className); int length = @in.ReadInt(); Assert.Equal("The int[] written by ObjectWritable as a non-compact array " + "was not expected length", i.Length, length); int[] readValue = new int[length]; try { for (int i = 0; i < length; i++) { readValue[i] = (int)((int)ObjectWritable.ReadObject(@in, null)); } } catch (Exception e) { Fail("The int[] written by ObjectWritable as a non-compact array " + "was corrupted. Failed to correctly read int[] of length " + length + ". Got exception:\n" + StringUtils.StringifyException(e)); } Assert.True("The int[] written by ObjectWritable as a non-compact array " + "was corrupted.", Arrays.Equals(i, readValue)); }
/// <summary> /// Write a protobuf to a buffer 'numProtos' times, and then /// read them back, making sure all data comes through correctly. /// </summary> /// <exception cref="System.IO.IOException"/> private void DoTest(int numProtos) { Configuration conf = new Configuration(); DataOutputBuffer @out = new DataOutputBuffer(); // Write numProtos protobufs to the buffer Message[] sent = new Message[numProtos]; for (int i = 0; i < numProtos; i++) { // Construct a test protocol buffer using one of the // protos that ships with the protobuf library Message testProto = ((DescriptorProtos.EnumValueDescriptorProto)DescriptorProtos.EnumValueDescriptorProto .NewBuilder().SetName("test" + i).SetNumber(i).Build()); ObjectWritable.WriteObject(@out, testProto, typeof(DescriptorProtos.EnumValueDescriptorProto ), conf); sent[i] = testProto; } // Read back the data DataInputBuffer @in = new DataInputBuffer(); @in.Reset(@out.GetData(), @out.GetLength()); for (int i_1 = 0; i_1 < numProtos; i_1++) { Message received = (Message)ObjectWritable.ReadObject(@in, conf); Assert.Equal(sent[i_1], received); } }
/// <exception cref="System.IO.IOException"/> public virtual void TestSerializeAndDeserializeNonEmpty() { DataOutputBuffer @out = new DataOutputBuffer(); ObjectWritable.WriteObject(@out, nonEmptyFlagWritable, nonEmptyFlagWritable.GetType (), null); DataInputBuffer @in = new DataInputBuffer(); @in.Reset(@out.GetData(), @out.GetLength()); EnumSet <TestEnumSetWritable.TestEnumSet> read = ((EnumSetWritable <TestEnumSetWritable.TestEnumSet >)ObjectWritable.ReadObject(@in, null)).Get(); Assert.Equal(read, nonEmptyFlag); }
public virtual void TestObjectLabeling() { //Do a few tricky experiments to make sure things are being written //the way we expect //Write the data array with ObjectWritable //which will indirectly write it using APW.Internal ObjectWritable.WriteObject(@out, i, i.GetType(), null, true); //Write the corresponding APW directly with ObjectWritable ArrayPrimitiveWritable apw = new ArrayPrimitiveWritable(i); ObjectWritable.WriteObject(@out, apw, apw.GetType(), null, true); //Get ready to read it back @in.Reset(@out.GetData(), @out.GetLength()); //Read the int[] object as written by ObjectWritable, but //"going around" ObjectWritable string className = UTF8.ReadString(@in); Assert.Equal("The int[] written by ObjectWritable was not labelled as " + "an ArrayPrimitiveWritable.Internal", typeof(ArrayPrimitiveWritable.Internal) .FullName, className); ArrayPrimitiveWritable.Internal apwi = new ArrayPrimitiveWritable.Internal(); apwi.ReadFields(@in); Assert.Equal("The ArrayPrimitiveWritable.Internal component type was corrupted" , typeof(int), apw.GetComponentType()); Assert.True("The int[] written by ObjectWritable as " + "ArrayPrimitiveWritable.Internal was corrupted" , Arrays.Equals(i, (int[])(apwi.Get()))); //Read the APW object as written by ObjectWritable, but //"going around" ObjectWritable string declaredClassName = UTF8.ReadString(@in); Assert.Equal("The APW written by ObjectWritable was not labelled as " + "declaredClass ArrayPrimitiveWritable", typeof(ArrayPrimitiveWritable).FullName , declaredClassName); className = UTF8.ReadString(@in); Assert.Equal("The APW written by ObjectWritable was not labelled as " + "class ArrayPrimitiveWritable", typeof(ArrayPrimitiveWritable).FullName, className ); ArrayPrimitiveWritable apw2 = new ArrayPrimitiveWritable(); apw2.ReadFields(@in); Assert.Equal("The ArrayPrimitiveWritable component type was corrupted" , typeof(int), apw2.GetComponentType()); Assert.True("The int[] written by ObjectWritable as " + "ArrayPrimitiveWritable was corrupted" , Arrays.Equals(i, (int[])(apw2.Get()))); }
/// <summary> /// Read a /// <see cref="IWritable"/> /// , /// <see cref="string"/> /// , primitive type, or an array of /// the preceding. /// </summary> /// <exception cref="System.IO.IOException"/> public static object ReadObject(BinaryReader reader, ObjectWritable objectWritable, Configuration conf) { string className = UTF8.ReadString(@in); Type declaredClass = PrimitiveNames[className]; if (declaredClass == null) { declaredClass = LoadClass(conf, className); } object instance; if (declaredClass.IsPrimitive) { // primitive types if (declaredClass == typeof(bool)) { // boolean instance = Extensions.ValueOf(@in.ReadBoolean()); } else { if (declaredClass == typeof(char)) { // char instance = char.ValueOf(@in.ReadChar()); } else { if (declaredClass == typeof(byte)) { // byte instance = byte.ValueOf(@in.ReadByte()); } else { if (declaredClass == typeof(short)) { // short instance = short.ValueOf(@in.ReadShort()); } else { if (declaredClass == typeof(int)) { // int instance = Extensions.ValueOf(@in.ReadInt()); } else { if (declaredClass == typeof(long)) { // long instance = Extensions.ValueOf(@in.ReadLong()); } else { if (declaredClass == typeof(float)) { // float instance = float.ValueOf(@in.ReadFloat()); } else { if (declaredClass == typeof(double)) { // double instance = double.ValueOf(@in.ReadDouble()); } else { if (declaredClass == typeof(void)) { // void instance = null; } else { throw new ArgumentException("Not a primitive: " + declaredClass); } } } } } } } } } } else { if (declaredClass.IsArray) { // array int length = @in.ReadInt(); instance = System.Array.CreateInstance(declaredClass.GetElementType(), length); for (int i = 0; i < length; i++) { Runtime.SetArrayValue(instance, i, ReadObject(@in, conf)); } } else { if (declaredClass == typeof(ArrayPrimitiveWritable.Internal)) { // Read and unwrap ArrayPrimitiveWritable$Internal array. // Always allow the read, even if write is disabled by allowCompactArrays. ArrayPrimitiveWritable.Internal temp = new ArrayPrimitiveWritable.Internal(); temp.ReadFields(@in); instance = temp.Get(); declaredClass = instance.GetType(); } else { if (declaredClass == typeof(string)) { // String instance = UTF8.ReadString(@in); } else { if (declaredClass.IsEnum()) { // enum instance = Enum.ValueOf((Type)declaredClass, UTF8.ReadString(@in)); } else { if (typeof(Message).IsAssignableFrom(declaredClass)) { instance = TryInstantiateProtobuf(declaredClass, @in); } else { // Writable Type instanceClass = null; string str = UTF8.ReadString(@in); instanceClass = LoadClass(conf, str); IWritable writable = WritableFactories.NewInstance(instanceClass, conf); writable.ReadFields(@in); instance = writable; if (instanceClass == typeof(ObjectWritable.NullInstance)) { // null declaredClass = ((ObjectWritable.NullInstance)instance).declaredClass; instance = null; } } } } } } } if (objectWritable != null) { // store values objectWritable.declaredClass = declaredClass; objectWritable.instance = instance; } return(instance); }