Java BaseJSTypeTestCase类代码示例

import com.google.javascript.rhino.testing.BaseJSTypeTestCase; //导入依赖的package包/类
public void testIgnoreUnknownType() {
  String js = ""
      + "/** @constructor */\n"
      + "function Foo() {}\n"
      + "Foo.prototype.blah = 3;\n"
      + "/** @type {Foo} */\n"
      + "var F = new Foo;\n"
      + "F.blah = 0;\n"
      + "var U = function() { return {} };\n"
      + "U().blah();";
  String expected = ""
      + "function Foo(){}Foo.prototype.blah=3;var F = new Foo;F.blah=0;"
      + "var U=function(){return{}};U().blah()";
  testSets(false, js, expected, "{}");
  testSets(true, BaseJSTypeTestCase.ALL_NATIVE_EXTERN_TYPES,
      js, expected, "{}");
}
 

import com.google.javascript.rhino.testing.BaseJSTypeTestCase; //导入依赖的package包/类
public void testUnresolvedType() {
  String js = ""
      + "var g = {};"
      + "/** @constructor \n @extends g.NotHere */ var Foo = function() {}\n"
      + "Foo.prototype.a = 0;"
      + "/** @constructor */ var Bar = function() {}\n"
      + "Bar.prototype.a = 0;";
  String output = ""
      + "var g={};"
      + "var Foo=function(){};"
      + "Foo.prototype.Foo_prototype$a=0;"
      + "var Bar=function(){};"
      + "Bar.prototype.Bar_prototype$a=0;";
  testSets(false, js, js, "{}");
  testSets(true, BaseJSTypeTestCase.ALL_NATIVE_EXTERN_TYPES,
      js, output, "{a=[[Bar.prototype], [Foo.prototype]]}");
}
 

import com.google.javascript.rhino.testing.BaseJSTypeTestCase; //导入依赖的package包/类
public void testUnknownType() {
  String js = ""
      + "/** @constructor */ var Foo = function() {};\n"
      + "/** @constructor */ var Bar = function() {};\n"
      + "function fun() {}\n"
      + "Foo.prototype.a = fun();\n"
      + "fun().a;\n"
      + "Bar.prototype.a = 0;";
  String ttOutput = ""
      + "var Foo=function(){};\n"
      + "var Bar=function(){};\n"
      + "function fun(){}\n"
      + "Foo.prototype.Foo_prototype$a=fun();\n"
      + "fun().Unique$1$a;\n"
      + "Bar.prototype.Bar_prototype$a=0;";
  testSets(false, js, js, "{}");
  testSets(true, BaseJSTypeTestCase.ALL_NATIVE_EXTERN_TYPES, js, ttOutput,
           "{a=[[Bar.prototype], [Foo.prototype], [Unique$1]]}");
}
 

import com.google.javascript.rhino.testing.BaseJSTypeTestCase; //导入依赖的package包/类
/**
 * Verifies that the compiler pass's JS output matches the expected output
 * and (optionally) that an expected warning is issued. Or, if an error is
 * expected, this method just verifies that the error is encountered.
 *
 * @param externs Externs inputs
 * @param js Input
 * @param expected Expected output, or null if an error is expected
 * @param error Expected error, or null if no error is expected
 * @param warning Expected warning, or null if no warning is expected
 * @param description The description of the expected warning,
 *      or null if no warning is expected or if the warning's description
 *      should not be examined
 */
public void test(JSSourceFile[] externs, String js, String expected,
                 DiagnosticType error,
                 DiagnosticType warning, String description) {
  Compiler compiler = createCompiler();
  lastCompiler = compiler;

  BaseJSTypeTestCase.addNativeProperties(compiler.getTypeRegistry());

  CompilerOptions options = getOptions();
  // Note that in this context, turning on the checkTypes option won't
  // actually cause the type check to run.
  options.checkTypes = parseTypeInfo;
  compiler.init(externs, new JSSourceFile[] {
      JSSourceFile.fromCode("testcode", js) }, options);
  test(compiler, new String[] { expected }, error, warning, description);
}
 

import com.google.javascript.rhino.testing.BaseJSTypeTestCase; //导入依赖的package包/类
public void testUnknownType() {
  String js = ""
      + "/** @constructor */ var Foo = function() {};\n"
      + "/** @constructor */ var Bar = function() {};\n"
      + "/** @return {?} */ function fun() {}\n"
      + "Foo.prototype.a = fun();\n"
      + "fun().a;\n"
      + "Bar.prototype.a = 0;";
  String ttOutput = ""
      + "var Foo=function(){};\n"
      + "var Bar=function(){};\n"
      + "function fun(){}\n"
      + "Foo.prototype.Foo_prototype$a=fun();\n"
      + "fun().Unique$1$a;\n"
      + "Bar.prototype.Bar_prototype$a=0;";
  testSets(false, js, js, "{}");
  testSets(true, BaseJSTypeTestCase.ALL_NATIVE_EXTERN_TYPES, js, ttOutput,
           "{a=[[Bar.prototype], [Foo.prototype], [Unique$1]]}");
}
 

import com.google.javascript.rhino.testing.BaseJSTypeTestCase; //导入依赖的package包/类
/**
 * Verifies that the compiler pass's JS output matches the expected output
 * and (optionally) that an expected warning is issued. Or, if an error is
 * expected, this method just verifies that the error is encountered.
 *
 * @param externs Externs inputs
 * @param js Input
 * @param expected Expected output, or null if an error is expected
 * @param error Expected error, or null if no error is expected
 * @param warning Expected warning, or null if no warning is expected
 * @param description The description of the expected warning,
 *      or null if no warning is expected or if the warning's description
 *      should not be examined
 */
public void test(JSSourceFile[] externs, String js, String expected,
                 DiagnosticType error,
                 DiagnosticType warning, String description) {
  Compiler compiler = createCompiler();
  lastCompiler = compiler;

  CompilerOptions options = getOptions();
  // Note that in this context, turning on the checkTypes option won't
  // actually cause the type check to run.
  options.checkTypes = parseTypeInfo;
  compiler.init(externs, new JSSourceFile[] {
      JSSourceFile.fromCode("testcode", js) }, options);

  BaseJSTypeTestCase.addNativeProperties(compiler.getTypeRegistry());

  test(compiler, new String[] { expected }, error, warning, description);
}
 

import com.google.javascript.rhino.testing.BaseJSTypeTestCase; //导入依赖的package包/类
public void testExternSubTypesForObject() {
  testSame(BaseJSTypeTestCase.ALL_NATIVE_EXTERN_TYPES
           + "/** @constructor */ function A() {};\n"
           + "/** @constructor \[email protected] A */ function B() {};\n"
           + "/** @return {Object} */ "
           + "Object.prototype.eval = function(code) {};\n"
           + "/** @type {Object} */\n"
           + "A.prototype.a;\n"
           + "/** @return {Object} */\n"
           + "A.prototype.b = function(){};\n",
           "var a = (new A).b()", null, null);
  assertType("(A,ActiveXObject,Array,B,Boolean,Date,Error,EvalError,"
             + "Function,Number,Object,"
             + "RangeError,ReferenceError,RegExp,String,SyntaxError,"
             + "TypeError,URIError)", getType("a"));
}
 

import com.google.javascript.rhino.testing.BaseJSTypeTestCase; //导入依赖的package包/类
public void testIgnoreUnknownType1() {
  String js = ""
      + "/** @constructor */\n"
      + "function Foo() {}\n"
      + "Foo.prototype.blah = 3;\n"
      + "/** @type {Foo} */\n"
      + "var F = new Foo;\n"
      + "F.blah = 0;\n"
      + "/** @return {Object} */\n"
      + "var U = function() { return {} };\n"
      + "U().blah();";
  String expected = ""
      + "function Foo(){}Foo.prototype.blah=3;var F = new Foo;F.blah=0;"
      + "var U=function(){return{}};U().blah()";
  testSets(false, js, expected, "{blah=[[Foo.prototype]]}");
  testSets(true, BaseJSTypeTestCase.ALL_NATIVE_EXTERN_TYPES,
      js, expected, "{}");
}
 

import com.google.javascript.rhino.testing.BaseJSTypeTestCase; //导入依赖的package包/类
public void testIgnoreUnknownType2() {
  String js = ""
      + "/** @constructor */\n"
      + "function Foo() {}\n"
      + "Foo.prototype.blah = 3;\n"
      + "/** @type {Foo} */\n"
      + "var F = new Foo;\n"
      + "F.blah = 0;\n"
      + "/** @constructor */\n"
      + "function Bar() {}\n"
      + "Bar.prototype.blah = 3;\n"
      + "/** @return {Object} */\n"
      + "var U = function() { return {} };\n"
      + "U().blah();";
  String expected = ""
      + "function Foo(){}Foo.prototype.blah=3;var F = new Foo;F.blah=0;"
      + "function Bar(){}Bar.prototype.blah=3;"
      + "var U=function(){return{}};U().blah()";
  testSets(false, js, expected, "{}");
  testSets(true, BaseJSTypeTestCase.ALL_NATIVE_EXTERN_TYPES,
      js, expected, "{}");
}
 

import com.google.javascript.rhino.testing.BaseJSTypeTestCase; //导入依赖的package包/类
public void testUnresolvedType() {
  // NOTE(nicksantos): This behavior seems very wrong to me.
  String js = ""
      + "var g = {};"
      + "/** @constructor \n @extends {?} */ "
      + "var Foo = function() {};\n"
      + "Foo.prototype.a = 0;"
      + "/** @constructor */ var Bar = function() {};\n"
      + "Bar.prototype.a = 0;";
  String output = ""
      + "var g={};"
      + "var Foo=function(){};"
      + "Foo.prototype.Foo_prototype$a=0;"
      + "var Bar=function(){};"
      + "Bar.prototype.Bar_prototype$a=0;";
  testSets(false, BaseJSTypeTestCase.ALL_NATIVE_EXTERN_TYPES,
      js, output, "{a=[[Bar.prototype], [Foo.prototype]]}");
  testSets(true, BaseJSTypeTestCase.ALL_NATIVE_EXTERN_TYPES,
      js, output, "{a=[[Bar.prototype], [Foo.prototype]]}");
}
 

import com.google.javascript.rhino.testing.BaseJSTypeTestCase; //导入依赖的package包/类
/**
 * Verifies that the compiler pass's JS output matches the expected output
 * and (optionally) that an expected warning is issued. Or, if an error is
 * expected, this method just verifies that the error is encountered.
 *
 * @param externs Externs inputs
 * @param js Input
 * @param expected Expected output, or null if an error is expected
 * @param error Expected error, or null if no error is expected
 * @param warning Expected warning, or null if no warning is expected
 * @param description The description of the expected warning,
 *      or null if no warning is expected or if the warning's description
 *      should not be examined
 */
public void test(List<SourceFile> externs, String js, String expected,
                 DiagnosticType error,
                 DiagnosticType warning, String description) {
  Compiler compiler = createCompiler();
  lastCompiler = compiler;

  CompilerOptions options = getOptions();

  if (this.acceptES5) {
    options.setLanguageIn(LanguageMode.ECMASCRIPT5);
  }
  // Note that in this context, turning on the checkTypes option won't
  // actually cause the type check to run.
  options.checkTypes = parseTypeInfo;
  compiler.init(externs, ImmutableList.of(
      SourceFile.fromCode(filename, js)), options);

  BaseJSTypeTestCase.addNativeProperties(compiler.getTypeRegistry());

  test(compiler, maybeCreateArray(expected), error, warning, description);
}
 

import com.google.javascript.rhino.testing.BaseJSTypeTestCase; //导入依赖的package包/类
protected void testInternal(
    Externs externs,
    Sources inputs,
    Expected expected,
    Diagnostic diagnostic,
    List<Postcondition> postconditions) {

  Compiler compiler = createCompiler();
  lastCompiler = compiler;

  CompilerOptions options = getOptions();

  if (inputs instanceof FlatSources) {
    options.setCheckTypes(parseTypeInfo || this.typeCheckEnabled);
    compiler.init(externs.externs, ((FlatSources) inputs).sources, options);
  } else {
    compiler.initModules(externsInputs, ((ModuleSources) inputs).modules, getOptions());
  }

  if (this.typeCheckEnabled) {
    BaseJSTypeTestCase.addNativeProperties(compiler.getTypeRegistry());
  }

  testInternal(compiler, inputs, expected, diagnostic, postconditions);
}
 

import com.google.javascript.rhino.testing.BaseJSTypeTestCase; //导入依赖的package包/类
public void testUnresolvedType() {
  // NOTE(nicksantos): This behavior seems very wrong to me.
  String js = ""
      + "var g = {};"
      + "/** @constructor \n @extends {?} */ "
      + "var Foo = function() {};\n"
      + "Foo.prototype.a = 0;"
      + "/** @constructor */ var Bar = function() {};\n"
      + "Bar.prototype.a = 0;";
  String output = ""
      + "var g={};"
      + "var Foo=function(){};"
      + "Foo.prototype.Foo_prototype$a=0;"
      + "var Bar=function(){};"
      + "Bar.prototype.Bar_prototype$a=0;";

  setExpectParseWarningsThisTest();
  testSets(BaseJSTypeTestCase.ALL_NATIVE_EXTERN_TYPES, js,
      output, "{a=[[Bar.prototype], [Foo.prototype]]}");
}
 

import com.google.javascript.rhino.testing.BaseJSTypeTestCase; //导入依赖的package包/类
public void testUnresolvedType() {
  // NOTE(nicksantos): This behavior seems very wrong to me.
  String js = ""
      + "var g = {};"
      + "/** @constructor \n @extends {?} */ "
      + "var Foo = function() {};\n"
      + "Foo.prototype.a = 0;"
      + "/** @constructor */ var Bar = function() {};\n"
      + "Bar.prototype.a = 0;";
  String output = ""
      + "var g={};"
      + "var Foo=function(){};"
      + "Foo.prototype.Foo_prototype$a=0;"
      + "var Bar=function(){};"
      + "Bar.prototype.Bar_prototype$a=0;";

  setExpectParseWarningsThisTest();
  testSets(false, BaseJSTypeTestCase.ALL_NATIVE_EXTERN_TYPES,
      js, output, "{a=[[Bar.prototype], [Foo.prototype]]}");
  testSets(true, BaseJSTypeTestCase.ALL_NATIVE_EXTERN_TYPES,
      js, output, "{a=[[Bar.prototype], [Foo.prototype]]}");
}
 

import com.google.javascript.rhino.testing.BaseJSTypeTestCase; //导入依赖的package包/类
public void testUntypedExterns() {
  String externs =
      BaseJSTypeTestCase.ALL_NATIVE_EXTERN_TYPES
      + "var window;"
      + "window.alert = function() {x};";
  String js = ""
      + "/** @constructor */ function Foo() {}\n"
      + "Foo.prototype.a = 0;\n"
      + "Foo.prototype.alert = 0;\n"
      + "Foo.prototype.window = 0;\n"
      + "/** @constructor */ function Bar() {}\n"
      + "Bar.prototype.a = 0;\n"
      + "Bar.prototype.alert = 0;\n"
      + "Bar.prototype.window = 0;\n"
      + "window.alert();";
  String output = ""
      + "function Foo(){}"
      + "Foo.prototype.Foo_prototype$a=0;"
      + "Foo.prototype.alert=0;"
      + "Foo.prototype.Foo_prototype$window=0;"
      + "function Bar(){}"
      + "Bar.prototype.Bar_prototype$a=0;"
      + "Bar.prototype.alert=0;"
      + "Bar.prototype.Bar_prototype$window=0;"
      + "window.alert();";

  testSets(false, externs, js, output, "{a=[[Bar.prototype], [Foo.prototype]]"
           + ", window=[[Bar.prototype], [Foo.prototype]]}");
  testSets(true, externs, js, output, "{a=[[Bar.prototype], [Foo.prototype]],"
           + " window=[[Bar.prototype], [Foo.prototype]]}");
}