library /*isNonNullableByDefault*/;
import self as self;
import "dart:supported.by.spec" as spec;
import "dart:_supported.by.target" as by_;
import "dart:unsupported.by.spec" as spec2;
import "dart:unsupported.by.target" as tar;
import "dart:_unsupported.by.spec_internal" as spe;
import "import_supported.by.spec_lib.dart" as spe2;
import "import_supported.by.target_lib.dart" as tar2;
import "dart:core" as core;

import "dart:supported.by.spec";
import "dart:unsupported.by.spec";
import "dart:unsupported.by.target";
import "org-dartlang-testcase:///import_supported.by.spec_lib.dart" as from_supported_by_spec_first;
import "org-dartlang-testcase:///import_supported.by.target_lib.dart" as from_supported_by_target;
import "org-dartlang-testcase:///import_supported.by.spec_lib.dart" as from_supported_by_spec_last;

static method main() → dynamic {
  spec::supportedBySpec();
  by_::supportedByTarget();
  spec2::unsupportedBySpec();
  tar::unsupportedByTarget();
  spe::unsupportedBySpecInternal();
  self::expect("supported.by.spec", spe2::field);
  self::expect("supported.by.target", tar2::field);
  self::expect("supported.by.spec", spe2::field);
  self::expect(true, #C1);
  self::expect(true, #C1);
  self::expect(false, #C2);
  self::expect(false, #C2);
  self::expect(false, #C2);
}
static method expect(dynamic expected, dynamic actual) → dynamic {
  if(!(expected =={core::Object::==}{(core::Object) → core::bool} actual))
    throw "Expected ${expected}, actual ${actual}";
}

library dart.supported.by.spec /*isNonNullableByDefault*/;
import self as spec;
import "dart:_supported.by.target" as by_;
additionalExports = (by_::supportedByTarget)

export "dart:_supported.by.target";

static method supportedBySpec() → void {}

library dart.unsupported.by.spec /*isUnsupported,isNonNullableByDefault*/;
import self as spec2;
import "dart:_unsupported.by.spec_internal" as spe;
additionalExports = (spe::unsupportedBySpecInternal)

export "dart:_unsupported.by.spec_internal";

static method unsupportedBySpec() → void {}

library dart.unsupported.by.target /*isNonNullableByDefault*/;
import self as tar;

static method unsupportedByTarget() → void {}

library /*isNonNullableByDefault*/;
import self as spe2;
import "dart:core" as core;

static field core::String field = "supported.by.spec";

library /*isNonNullableByDefault*/;
import self as tar2;
import "dart:core" as core;

static field core::String field = "supported.by.target";

library dart._supported.by_target /*isUnsupported,isNonNullableByDefault*/;
import self as by_;

static method supportedByTarget() → void {}

library dart._unsupported.by.spec_internal /*isUnsupported,isNonNullableByDefault*/;
import self as spe;

static method unsupportedBySpecInternal() → void {}

constants  {
  #C1 = true
  #C2 = false
}