Exemplo n.º 1
0
        public void EncodeDecodeKeyValueSchemaInfoSEPARATED()
        {
            var encodingType = KeyValueEncodingType.SEPARATED;
            var kvSchema     = ISchema <object> .KeyValue(FooSchema, BarSchema, encodingType);

            var kvSchemaInfo = kvSchema.SchemaInfo;

            Assert.Equal(encodingType, DefaultImplementation.DecodeKeyValueEncodingType(kvSchemaInfo));

            var encodedSchemaInfo = DefaultImplementation.EncodeKeyValueSchemaInfo(FooSchema, BarSchema, encodingType);

            for (var i = 0; i < kvSchemaInfo.Schema.Length; i++)
            {
                var expected = kvSchemaInfo.Schema[i];
                var actual   = encodedSchemaInfo.Schema[i];
                Assert.Equal(expected, actual);
            }
            Assert.Equal(encodingType, DefaultImplementation.DecodeKeyValueEncodingType(encodedSchemaInfo));

            var schemaInfoKeyValue = DefaultImplementation.DecodeKeyValueSchemaInfo(kvSchemaInfo);

            for (var i = 0; i < FooSchema.SchemaInfo.Schema.Length; i++)
            {
                var expected = FooSchema.SchemaInfo.Schema[i];
                var actual   = schemaInfoKeyValue.Key.Schema[i];
                Assert.Equal(expected, actual);
            }

            for (var i = 0; i < BarSchema.SchemaInfo.Schema.Length; i++)
            {
                var expected = BarSchema.SchemaInfo.Schema[i];
                var actual   = schemaInfoKeyValue.Value.Schema[i];
                Assert.Equal(expected, actual);
            }
        }
Exemplo n.º 2
0
        public void EncodeDecodeNestedKeyValueSchemaInfo()
        {
            var encodingType = KeyValueEncodingType.INLINE;
            var nestedSchema = ISchema <object> .KeyValue(ISchema <object> .String, BarSchema, KeyValueEncodingType.INLINE);

            var kvSchema = ISchema <object> .KeyValue(FooSchema, nestedSchema, encodingType);

            var kvSchemaInfo = kvSchema.SchemaInfo;

            Assert.Equal(encodingType, DefaultImplementation.DecodeKeyValueEncodingType(kvSchemaInfo));

            var encodedSchemaInfo = DefaultImplementation.EncodeKeyValueSchemaInfo(FooSchema, nestedSchema, encodingType);

            for (var i = 0; i < kvSchemaInfo.Schema.Length; i++)
            {
                var expected = kvSchemaInfo.Schema[i];
                var actual   = encodedSchemaInfo.Schema[i];
                Assert.Equal(expected, actual);
            }
            Assert.Equal(encodingType, DefaultImplementation.DecodeKeyValueEncodingType(encodedSchemaInfo));

            var schemaInfoKeyValue = DefaultImplementation.DecodeKeyValueSchemaInfo(kvSchemaInfo);


            for (var i = 0; i < FooSchema.SchemaInfo.Schema.Length; i++)
            {
                var expected = FooSchema.SchemaInfo.Schema[i];
                var actual   = schemaInfoKeyValue.Key.Schema[i];
                Assert.Equal(expected, actual);
            }
            Assert.Equal(schemaInfoKeyValue.Value.Type, SchemaType.KeyValue);
            var nestedSchemaInfoKeyValue = DefaultImplementation.DecodeKeyValueSchemaInfo(schemaInfoKeyValue.Value);

            var stringSchema = ISchema <object> .String.SchemaInfo.Schema;

            for (var i = 0; i < stringSchema.Length; i++)
            {
                var expected = stringSchema[i];
                var actual   = nestedSchemaInfoKeyValue.Key.Schema[i];
                Assert.Equal(expected, actual);
            }
            for (var i = 0; i < BarSchema.SchemaInfo.Schema.Length; i++)
            {
                var expected = BarSchema.SchemaInfo.Schema[i];
                var actual   = nestedSchemaInfoKeyValue.Value.Schema[i];
                Assert.Equal(expected, actual);
            }
        }
Exemplo n.º 3
0
        public virtual void TestKeyValueSchemaInfoBackwardCompatibility()
        {
            var kvSchema = ISchema <object> .KeyValue(FooSchema, BarSchema, KeyValueEncodingType.SEPARATED);

            var oldSchemaInfo = new SchemaInfo {
                Name       = "",
                Type       = SchemaType.KeyValue,
                Schema     = kvSchema.SchemaInfo.Schema,
                Properties = new Dictionary <string, string>()
            };

            Assert.Equal(KeyValueEncodingType.INLINE, DefaultImplementation.DecodeKeyValueEncodingType(oldSchemaInfo));

            var schemaInfoKeyValue = DefaultImplementation.DecodeKeyValueSchemaInfo(oldSchemaInfo);
            // verify the key schemaS
            var keySchemaInfo = schemaInfoKeyValue.Key;

            Assert.Equal(SchemaType.BYTES, keySchemaInfo.Type);

            for (var i = 0; i < FooSchema.SchemaInfo.Schema.Length; i++)
            {
                var expected = FooSchema.SchemaInfo.Schema[i];
                var actual   = keySchemaInfo.Schema[i];
                Assert.Equal(expected, actual);
            }

            Assert.False(FooSchema.SchemaInfo.Properties.Count == 0);
            Assert.True(keySchemaInfo.Properties.Count == 0);
            // verify the value schema
            var valueSchemaInfo = schemaInfoKeyValue.Value;

            Assert.Equal(SchemaType.BYTES, valueSchemaInfo.Type);
            for (var i = 0; i < BarSchema.SchemaInfo.Schema.Length; i++)
            {
                var expected = BarSchema.SchemaInfo.Schema[i];
                var actual   = valueSchemaInfo.Schema[i];
                Assert.Equal(expected, actual);
            }
            Assert.False(BarSchema.SchemaInfo.Properties.Count == 0);
            Assert.True(valueSchemaInfo.Properties.Count == 0);
        }