| // Copyright 2020 Google LLC |
| // |
| // Licensed under the Apache License, Version 2.0 (the "License"); |
| // you may not use this file except in compliance with the License. |
| // You may obtain a copy of the License at |
| // |
| // https://www.apache.org/licenses/LICENSE-2.0 |
| // |
| // Unless required by applicable law or agreed to in writing, software |
| // distributed under the License is distributed on an "AS IS" BASIS, |
| // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| // See the License for the specific language governing permissions and |
| // limitations under the License. |
| |
| import 'dart:io'; |
| |
| import 'package:test/test.dart'; |
| import 'package:yaml/yaml.dart'; |
| import 'package:yaml_edit/src/equality.dart'; |
| import 'package:yaml_edit/src/wrap.dart'; |
| |
| import 'test_utils.dart'; |
| |
| void main() { |
| group('wrapAsYamlNode', () { |
| group('checks for invalid scalars', () { |
| test('fails to wrap an invalid scalar', () { |
| expect(() => wrapAsYamlNode(File('test.dart')), throwsArgumentError); |
| }); |
| |
| test('fails to wrap an invalid map', () { |
| expect(() => wrapAsYamlNode({'a': File('test.dart')}), |
| throwsArgumentError); |
| }); |
| |
| test('fails to wrap an invalid list', () { |
| expect( |
| () => wrapAsYamlNode([ |
| 'a', |
| [File('test.dart')] |
| ]), |
| throwsArgumentError); |
| }); |
| |
| test('checks YamlScalar for invalid scalar value', () { |
| expect(() => wrapAsYamlNode(YamlScalar.wrap(File('test.dart'))), |
| throwsArgumentError); |
| }); |
| |
| test('checks YamlMap for deep invalid scalar value', () { |
| expect( |
| () => wrapAsYamlNode(YamlMap.wrap({ |
| 'a': {'b': File('test.dart')} |
| })), |
| throwsArgumentError); |
| }); |
| |
| test('checks YamlList for deep invalid scalar value', () { |
| expect( |
| () => wrapAsYamlNode(YamlList.wrap([ |
| 'a', |
| [File('test.dart')] |
| ])), |
| throwsArgumentError); |
| }); |
| }); |
| |
| test('wraps scalars', () { |
| final scalar = wrapAsYamlNode('foo'); |
| |
| expect((scalar as YamlScalar).style, equals(ScalarStyle.ANY)); |
| expect(scalar.value, equals('foo')); |
| }); |
| |
| test('wraps scalars with style', () { |
| final scalar = |
| wrapAsYamlNode('foo', scalarStyle: ScalarStyle.DOUBLE_QUOTED); |
| |
| expect((scalar as YamlScalar).style, equals(ScalarStyle.DOUBLE_QUOTED)); |
| expect(scalar.value, equals('foo')); |
| }); |
| |
| test('wraps lists', () { |
| final list = wrapAsYamlNode([ |
| [1, 2, 3], |
| { |
| 'foo': 'bar', |
| 'nested': [4, 5, 6] |
| }, |
| 'value' |
| ]); |
| |
| expect( |
| list, |
| equals([ |
| [1, 2, 3], |
| { |
| 'foo': 'bar', |
| 'nested': [4, 5, 6] |
| }, |
| 'value' |
| ])); |
| expect((list as YamlList).style, equals(CollectionStyle.ANY)); |
| expect(list[0].style, equals(CollectionStyle.ANY)); |
| expect(list[1].style, equals(CollectionStyle.ANY)); |
| }); |
| |
| test('wraps lists with collectionStyle', () { |
| final list = wrapAsYamlNode([ |
| [1, 2, 3], |
| { |
| 'foo': 'bar', |
| 'nested': [4, 5, 6] |
| }, |
| 'value' |
| ], collectionStyle: CollectionStyle.BLOCK); |
| |
| expect((list as YamlList).style, equals(CollectionStyle.BLOCK)); |
| expect(list[0].style, equals(CollectionStyle.ANY)); |
| expect(list[1].style, equals(CollectionStyle.ANY)); |
| }); |
| |
| test('wraps nested lists while preserving style', () { |
| final list = wrapAsYamlNode([ |
| wrapAsYamlNode([1, 2, 3], collectionStyle: CollectionStyle.FLOW), |
| wrapAsYamlNode({ |
| 'foo': 'bar', |
| 'nested': [4, 5, 6] |
| }, collectionStyle: CollectionStyle.FLOW), |
| 'value' |
| ], collectionStyle: CollectionStyle.BLOCK); |
| |
| expect((list as YamlList).style, equals(CollectionStyle.BLOCK)); |
| expect(list[0].style, equals(CollectionStyle.FLOW)); |
| expect(list[1].style, equals(CollectionStyle.FLOW)); |
| }); |
| |
| test('wraps maps', () { |
| final map = wrapAsYamlNode({ |
| 'list': [1, 2, 3], |
| 'map': { |
| 'foo': 'bar', |
| 'nested': [4, 5, 6] |
| }, |
| 'scalar': 'value' |
| }); |
| |
| expect( |
| map, |
| equals({ |
| 'list': [1, 2, 3], |
| 'map': { |
| 'foo': 'bar', |
| 'nested': [4, 5, 6] |
| }, |
| 'scalar': 'value' |
| })); |
| |
| expect((map as YamlMap).style, equals(CollectionStyle.ANY)); |
| }); |
| |
| test('wraps maps with collectionStyle', () { |
| final map = wrapAsYamlNode({ |
| 'list': [1, 2, 3], |
| 'map': { |
| 'foo': 'bar', |
| 'nested': [4, 5, 6] |
| }, |
| 'scalar': 'value' |
| }, collectionStyle: CollectionStyle.BLOCK); |
| |
| expect((map as YamlMap).style, equals(CollectionStyle.BLOCK)); |
| }); |
| |
| test('wraps nested maps while preserving style', () { |
| final map = wrapAsYamlNode({ |
| 'list': |
| wrapAsYamlNode([1, 2, 3], collectionStyle: CollectionStyle.FLOW), |
| 'map': wrapAsYamlNode({ |
| 'foo': 'bar', |
| 'nested': [4, 5, 6] |
| }, collectionStyle: CollectionStyle.BLOCK), |
| 'scalar': 'value' |
| }, collectionStyle: CollectionStyle.BLOCK); |
| |
| expect((map as YamlMap).style, equals(CollectionStyle.BLOCK)); |
| expect(map['list'].style, equals(CollectionStyle.FLOW)); |
| expect(map['map'].style, equals(CollectionStyle.BLOCK)); |
| }); |
| |
| test('works with YamlMap.wrap', () { |
| final map = wrapAsYamlNode({ |
| 'list': |
| wrapAsYamlNode([1, 2, 3], collectionStyle: CollectionStyle.FLOW), |
| 'map': YamlMap.wrap({ |
| 'foo': 'bar', |
| 'nested': [4, 5, 6] |
| }), |
| }, collectionStyle: CollectionStyle.BLOCK); |
| |
| expect((map as YamlMap).style, equals(CollectionStyle.BLOCK)); |
| expect(map['list'].style, equals(CollectionStyle.FLOW)); |
| expect(map['map'].style, equals(CollectionStyle.ANY)); |
| }); |
| }); |
| |
| group('deepHashCode', () { |
| test('returns the same result for scalar and its value', () { |
| final hashCode1 = deepHashCode('foo'); |
| final hashCode2 = deepHashCode(wrapAsYamlNode('foo')); |
| |
| expect(hashCode1, equals(hashCode2)); |
| }); |
| |
| test('returns different results for different values', () { |
| final hashCode1 = deepHashCode('foo'); |
| final hashCode2 = deepHashCode(wrapAsYamlNode('bar')); |
| |
| expect(hashCode1, notEquals(hashCode2)); |
| }); |
| |
| test('returns the same result for YamlScalar with style and its value', () { |
| final hashCode1 = deepHashCode('foo'); |
| final hashCode2 = |
| deepHashCode(wrapAsYamlNode('foo', scalarStyle: ScalarStyle.LITERAL)); |
| |
| expect(hashCode1, equals(hashCode2)); |
| }); |
| |
| test( |
| 'returns the same result for two YamlScalars with same value but different styles', |
| () { |
| final hashCode1 = |
| deepHashCode(wrapAsYamlNode('foo', scalarStyle: ScalarStyle.PLAIN)); |
| final hashCode2 = |
| deepHashCode(wrapAsYamlNode('foo', scalarStyle: ScalarStyle.LITERAL)); |
| |
| expect(hashCode1, equals(hashCode2)); |
| }); |
| |
| test('returns the same result for list and its value', () { |
| final hashCode1 = deepHashCode([1, 2, 3]); |
| final hashCode2 = deepHashCode(wrapAsYamlNode([1, 2, 3])); |
| |
| expect(hashCode1, equals(hashCode2)); |
| }); |
| |
| test('returns the same result for list and the YamlList.wrap() value', () { |
| final hashCode1 = deepHashCode([ |
| 1, |
| [1, 2], |
| 3 |
| ]); |
| final hashCode2 = deepHashCode(YamlList.wrap([ |
| 1, |
| YamlList.wrap([1, 2]), |
| 3 |
| ])); |
| |
| expect(hashCode1, equals(hashCode2)); |
| }); |
| |
| test('returns the different results for different lists', () { |
| final hashCode1 = deepHashCode([1, 2, 3]); |
| final hashCode2 = deepHashCode([1, 2, 4]); |
| final hashCode3 = deepHashCode([1, 2, 3, 4]); |
| |
| expect(hashCode1, notEquals(hashCode2)); |
| expect(hashCode2, notEquals(hashCode3)); |
| expect(hashCode3, notEquals(hashCode1)); |
| }); |
| |
| test('returns the same result for YamlList with style and its value', () { |
| final hashCode1 = deepHashCode([1, 2, 3]); |
| final hashCode2 = deepHashCode( |
| wrapAsYamlNode([1, 2, 3], collectionStyle: CollectionStyle.FLOW)); |
| |
| expect(hashCode1, equals(hashCode2)); |
| }); |
| |
| test( |
| 'returns the same result for two YamlLists with same value but different styles', |
| () { |
| final hashCode1 = deepHashCode( |
| wrapAsYamlNode([1, 2, 3], collectionStyle: CollectionStyle.BLOCK)); |
| final hashCode2 = deepHashCode(wrapAsYamlNode([1, 2, 3])); |
| |
| expect(hashCode1, equals(hashCode2)); |
| }); |
| |
| test('returns the same result for a map and its value', () { |
| final hashCode1 = deepHashCode({'a': 1, 'b': 2}); |
| final hashCode2 = deepHashCode(wrapAsYamlNode({'a': 1, 'b': 2})); |
| |
| expect(hashCode1, equals(hashCode2)); |
| }); |
| |
| test('returns the same result for list and the YamlList.wrap() value', () { |
| final hashCode1 = deepHashCode({ |
| 'a': 1, |
| 'b': 2, |
| 'c': {'d': 4, 'e': 5} |
| }); |
| final hashCode2 = deepHashCode(YamlMap.wrap({ |
| 'a': 1, |
| 'b': 2, |
| 'c': YamlMap.wrap({'d': 4, 'e': 5}) |
| })); |
| |
| expect(hashCode1, equals(hashCode2)); |
| }); |
| |
| test('returns the different results for different maps', () { |
| final hashCode1 = deepHashCode({'a': 1, 'b': 2}); |
| final hashCode2 = deepHashCode({'a': 1, 'b': 3}); |
| final hashCode3 = deepHashCode({'a': 1, 'b': 2, 'c': 3}); |
| |
| expect(hashCode1, notEquals(hashCode2)); |
| expect(hashCode2, notEquals(hashCode3)); |
| expect(hashCode3, notEquals(hashCode1)); |
| }); |
| |
| test('returns the same result for YamlMap with style and its value', () { |
| final hashCode1 = deepHashCode({'a': 1, 'b': 2}); |
| final hashCode2 = deepHashCode(wrapAsYamlNode({'a': 1, 'b': 2}, |
| collectionStyle: CollectionStyle.FLOW)); |
| |
| expect(hashCode1, equals(hashCode2)); |
| }); |
| |
| test( |
| 'returns the same result for two YamlMaps with same value but ' |
| 'different styles', () { |
| final hashCode1 = deepHashCode(wrapAsYamlNode({'a': 1, 'b': 2}, |
| collectionStyle: CollectionStyle.BLOCK)); |
| final hashCode2 = deepHashCode(wrapAsYamlNode({'a': 1, 'b': 2}, |
| collectionStyle: CollectionStyle.FLOW)); |
| |
| expect(hashCode1, equals(hashCode2)); |
| }); |
| }); |
| } |