utils_test.dart 5.41 KB
Newer Older
1 2 3 4
// Copyright 2016 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

5 6
import 'dart:async';

7
import 'package:flutter_tools/src/base/utils.dart';
8
import 'package:flutter_tools/src/base/version.dart';
9 10

import 'src/common.dart';
11 12 13 14

void main() {
  group('SettingsFile', () {
    test('parse', () {
15
      final SettingsFile file = new SettingsFile.parse('''
16 17 18 19 20 21 22 23 24
# ignore comment
foo=bar
baz=qux
''');
      expect(file.values['foo'], 'bar');
      expect(file.values['baz'], 'qux');
      expect(file.values, hasLength(2));
    });
  });
25 26 27 28

  group('uuid', () {
    // xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx
    test('simple', () {
29 30
      final Uuid uuid = new Uuid();
      final String result = uuid.generateV4();
31 32 33 34 35 36 37 38
      expect(result.length, 36);
      expect(result[8], '-');
      expect(result[13], '-');
      expect(result[18], '-');
      expect(result[23], '-');
    });

    test('can parse', () {
39 40
      final Uuid uuid = new Uuid();
      final String result = uuid.generateV4();
41 42 43 44 45 46 47 48
      expect(int.parse(result.substring(0, 8), radix: 16), isNotNull);
      expect(int.parse(result.substring(9, 13), radix: 16), isNotNull);
      expect(int.parse(result.substring(14, 18), radix: 16), isNotNull);
      expect(int.parse(result.substring(19, 23), radix: 16), isNotNull);
      expect(int.parse(result.substring(24, 36), radix: 16), isNotNull);
    });

    test('special bits', () {
49
      final Uuid uuid = new Uuid();
50 51 52 53 54 55 56 57 58 59 60 61
      String result = uuid.generateV4();
      expect(result[14], '4');
      expect(result[19].toLowerCase(), isIn('89ab'));

      result = uuid.generateV4();
      expect(result[19].toLowerCase(), isIn('89ab'));

      result = uuid.generateV4();
      expect(result[19].toLowerCase(), isIn('89ab'));
    });

    test('is pretty random', () {
62
      final Set<String> set = new Set<String>();
63 64 65

      Uuid uuid = new Uuid();
      for (int i = 0; i < 64; i++) {
66
        final String val = uuid.generateV4();
67 68 69 70 71 72
        expect(set, isNot(contains(val)));
        set.add(val);
      }

      uuid = new Uuid();
      for (int i = 0; i < 64; i++) {
73
        final String val = uuid.generateV4();
74 75 76 77 78 79
        expect(set, isNot(contains(val)));
        set.add(val);
      }

      uuid = new Uuid();
      for (int i = 0; i < 64; i++) {
80
        final String val = uuid.generateV4();
81 82 83 84 85
        expect(set, isNot(contains(val)));
        set.add(val);
      }
    });
  });
86 87 88 89 90 91

  group('Version', () {
    test('can parse and compare', () {
      expect(Version.unknown.toString(), equals('unknown'));
      expect(new Version(null, null, null).toString(), equals('0'));

92
      final Version v1 = new Version.parse('1');
93 94 95 96 97 98
      expect(v1.major, equals(1));
      expect(v1.minor, equals(0));
      expect(v1.patch, equals(0));

      expect(v1, greaterThan(Version.unknown));

99
      final Version v2 = new Version.parse('1.2');
100 101 102 103
      expect(v2.major, equals(1));
      expect(v2.minor, equals(2));
      expect(v2.patch, equals(0));

104
      final Version v3 = new Version.parse('1.2.3');
105 106 107 108
      expect(v3.major, equals(1));
      expect(v3.minor, equals(2));
      expect(v3.patch, equals(3));

109
      final Version v4 = new Version.parse('1.12');
110 111 112 113 114
      expect(v4, greaterThan(v2));

      expect(v3, greaterThan(v2));
      expect(v2, greaterThan(v1));

115
      final Version v5 = new Version(1, 2, 0, text: 'foo');
116
      expect(v5, equals(v2));
117 118

      expect(new Version.parse('Preview2.2'), isNull);
119 120
    });
  });
121 122

  group('Poller', () {
123
    const Duration kShortDelay = Duration(milliseconds: 100);
124 125 126 127 128 129 130 131 132

    Poller poller;

    tearDown(() {
      poller?.cancel();
    });

    test('fires at start', () async {
      bool called = false;
133
      poller = new Poller(() async {
134 135 136 137 138 139 140 141 142 143
        called = true;
      }, const Duration(seconds: 1));
      expect(called, false);
      await new Future<Null>.delayed(kShortDelay);
      expect(called, true);
    });

    test('runs periodically', () async {
      // Ensure we get the first (no-delay) callback, and one of the periodic callbacks.
      int callCount = 0;
144
      poller = new Poller(() async {
145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168
        callCount++;
      }, new Duration(milliseconds: kShortDelay.inMilliseconds ~/ 2));
      expect(callCount, 0);
      await new Future<Null>.delayed(kShortDelay);
      expect(callCount, greaterThanOrEqualTo(2));
    });

    test('no quicker then the periodic delay', () async {
      // Make sure that the poller polls at delay + the time it took to run the callback.
      final Completer<Duration> completer = new Completer<Duration>();
      DateTime firstTime;
      poller = new Poller(() async {
        if (firstTime == null)
          firstTime = new DateTime.now();
        else
          completer.complete(new DateTime.now().difference(firstTime));

        // introduce a delay
        await new Future<Null>.delayed(kShortDelay);
      }, kShortDelay);
      final Duration duration = await completer.future;
      expect(duration, greaterThanOrEqualTo(new Duration(milliseconds: kShortDelay.inMilliseconds * 2)));
    });
  });
169 170 171 172 173 174 175 176 177 178 179 180 181

  group('Misc', () {
    test('snakeCase', () async {
      expect(snakeCase('abc'), equals('abc'));
      expect(snakeCase('abC'), equals('ab_c'));
      expect(snakeCase('aBc'), equals('a_bc'));
      expect(snakeCase('aBC'), equals('a_b_c'));
      expect(snakeCase('Abc'), equals('abc'));
      expect(snakeCase('AbC'), equals('ab_c'));
      expect(snakeCase('ABc'), equals('a_bc'));
      expect(snakeCase('ABC'), equals('a_b_c'));
    });
  });
182
}