// Copyright (c) 2014, the Dart project authors. Please see the AUTHORS file
// for details. All rights reserved. Use of this source code is governed by a
// BSD-style license that can be found in the LICENSE file.

import 'package:analysis_server/src/services/correction/status.dart';
import 'package:analysis_server/src/services/refactoring/naming_conventions.dart';
import 'package:analysis_server/src/services/refactoring/refactoring.dart';
import 'package:analyzer_plugin/protocol/protocol_common.dart'
    show RefactoringProblemSeverity;
import 'package:test_reflective_loader/test_reflective_loader.dart';

import 'abstract_refactoring.dart';

void main() {
  defineReflectiveSuite(() {
    defineReflectiveTests(NamingConventionsTest);
  });
}

@reflectiveTest
class NamingConventionsTest extends RefactoringTest {
  @override
  Refactoring get refactoring => null;

  void test_validateClassName_doesNotStartWithLowerCase() {
    assertRefactoringStatus(
        validateClassName('newName'), RefactoringProblemSeverity.WARNING,
        expectedMessage: 'Class name should start with an uppercase letter.');
  }

  void test_validateClassName_empty() {
    assertRefactoringStatus(
        validateClassName(''), RefactoringProblemSeverity.FATAL,
        expectedMessage: 'Class name must not be empty.');
  }

  void test_validateClassName_invalidCharacter() {
    assertRefactoringStatus(
        validateClassName('-NewName'), RefactoringProblemSeverity.FATAL,
        expectedMessage: "Class name must not contain '-'.");
  }

  void test_validateClassName_leadingBlanks() {
    assertRefactoringStatus(
        validateClassName(' NewName'), RefactoringProblemSeverity.FATAL,
        expectedMessage: 'Class name must not start or end with a blank.');
  }

  void test_validateClassName_notIdentifierMiddle() {
    assertRefactoringStatus(
        validateClassName('New-Name'), RefactoringProblemSeverity.FATAL,
        expectedMessage: "Class name must not contain '-'.");
  }

  void test_validateClassName_notIdentifierStart() {
    assertRefactoringStatus(
        validateClassName('badName'), RefactoringProblemSeverity.WARNING,
        expectedMessage: 'Class name should start with an uppercase letter.');
  }

  void test_validateClassName_null() {
    assertRefactoringStatus(
        validateClassName(null), RefactoringProblemSeverity.FATAL,
        expectedMessage: 'Class name must not be null.');
  }

  void test_validateClassName_OK() {
    assertRefactoringStatusOK(validateClassName('NewName'));
  }

  void test_validateClassName_OK_leadingDollar() {
    assertRefactoringStatusOK(validateClassName('\$NewName'));
  }

  void test_validateClassName_OK_leadingUnderscore() {
    assertRefactoringStatusOK(validateClassName('_NewName'));
  }

  void test_validateClassName_OK_middleDollar() {
    assertRefactoringStatusOK(validateClassName('New\$Name'));
  }

  void test_validateClassName_trailingBlanks() {
    assertRefactoringStatus(
        validateClassName('NewName '), RefactoringProblemSeverity.FATAL,
        expectedMessage: 'Class name must not start or end with a blank.');
  }

  void test_validateConstructorName_doesNotStartWithLowerCase() {
    assertRefactoringStatus(
        validateConstructorName('NewName'), RefactoringProblemSeverity.WARNING,
        expectedMessage:
            'Constructor name should start with a lowercase letter.');
  }

  void test_validateConstructorName_empty() {
    assertRefactoringStatusOK(validateConstructorName(''));
  }

  void test_validateConstructorName_leadingBlanks() {
    assertRefactoringStatus(
        validateConstructorName(' newName'), RefactoringProblemSeverity.FATAL,
        expectedMessage:
            'Constructor name must not start or end with a blank.');
  }

  void test_validateConstructorName_notIdentifierMiddle() {
    assertRefactoringStatus(
        validateConstructorName('na-me'), RefactoringProblemSeverity.FATAL,
        expectedMessage: "Constructor name must not contain '-'.");
  }

  void test_validateConstructorName_notIdentifierStart() {
    assertRefactoringStatus(
        validateConstructorName('2name'), RefactoringProblemSeverity.FATAL,
        expectedMessage:
            'Constructor name must begin with a lowercase letter or underscore.');
  }

  void test_validateConstructorName_null() {
    assertRefactoringStatus(
        validateConstructorName(null), RefactoringProblemSeverity.FATAL,
        expectedMessage: 'Constructor name must not be null.');
  }

  void test_validateConstructorName_OK() {
    assertRefactoringStatusOK(validateConstructorName('newName'));
  }

  void test_validateConstructorName_OK_leadingUnderscore() {
    assertRefactoringStatusOK(validateConstructorName('_newName'));
  }

  void test_validateConstructorName_trailingBlanks() {
    assertRefactoringStatus(
        validateConstructorName('newName '), RefactoringProblemSeverity.FATAL,
        expectedMessage:
            'Constructor name must not start or end with a blank.');
  }

  void test_validateFieldName_doesNotStartWithLowerCase() {
    assertRefactoringStatus(
        validateFieldName('NewName'), RefactoringProblemSeverity.WARNING,
        expectedMessage: 'Field name should start with a lowercase letter.');
  }

  void test_validateFieldName_empty() {
    assertRefactoringStatus(
        validateFieldName(''), RefactoringProblemSeverity.FATAL,
        expectedMessage: 'Field name must not be empty.');
  }

  void test_validateFieldName_keyword() {
    assertRefactoringStatus(
        validateFieldName('for'), RefactoringProblemSeverity.FATAL,
        expectedMessage: 'Field name must not be a keyword.');
  }

  void test_validateFieldName_leadingBlanks() {
    assertRefactoringStatus(
        validateFieldName(' newName'), RefactoringProblemSeverity.FATAL,
        expectedMessage: 'Field name must not start or end with a blank.');
  }

  void test_validateFieldName_notIdentifierMiddle() {
    assertRefactoringStatus(
        validateFieldName('new-Name'), RefactoringProblemSeverity.FATAL,
        expectedMessage: "Field name must not contain '-'.");
  }

  void test_validateFieldName_notIdentifierStart() {
    assertRefactoringStatus(
        validateFieldName('2newName'), RefactoringProblemSeverity.FATAL,
        expectedMessage:
            'Field name must begin with a lowercase letter or underscore.');
  }

  void test_validateFieldName_null() {
    assertRefactoringStatus(
        validateFieldName(null), RefactoringProblemSeverity.FATAL,
        expectedMessage: 'Field name must not be null.');
  }

  void test_validateFieldName_OK() {
    assertRefactoringStatusOK(validateFieldName('newName'));
  }

  void test_validateFieldName_OK_leadingUnderscore() {
    assertRefactoringStatusOK(validateFieldName('_newName'));
  }

  void test_validateFieldName_OK_middleUnderscore() {
    assertRefactoringStatusOK(validateFieldName('new_name'));
  }

  void test_validateFieldName_pseudoKeyword() {
    _assertWarningBuiltIn(validateFieldName('await'));
  }

  void test_validateFieldName_trailingBlanks() {
    assertRefactoringStatus(
        validateFieldName('newName '), RefactoringProblemSeverity.FATAL,
        expectedMessage: 'Field name must not start or end with a blank.');
  }

  void test_validateFunctionName_doesNotStartWithLowerCase() {
    assertRefactoringStatus(
        validateFunctionName('NewName'), RefactoringProblemSeverity.WARNING,
        expectedMessage: 'Function name should start with a lowercase letter.');
  }

  void test_validateFunctionName_empty() {
    assertRefactoringStatus(
        validateFunctionName(''), RefactoringProblemSeverity.FATAL,
        expectedMessage: 'Function name must not be empty.');
  }

  void test_validateFunctionName_keyword() {
    assertRefactoringStatus(
        validateFunctionName('new'), RefactoringProblemSeverity.FATAL,
        expectedMessage: 'Function name must not be a keyword.');
  }

  void test_validateFunctionName_leadingBlanks() {
    assertRefactoringStatus(
        validateFunctionName(' newName'), RefactoringProblemSeverity.FATAL,
        expectedMessage: 'Function name must not start or end with a blank.');
  }

  void test_validateFunctionName_notIdentifierMiddle() {
    assertRefactoringStatus(
        validateFunctionName('new-Name'), RefactoringProblemSeverity.FATAL,
        expectedMessage: "Function name must not contain '-'.");
  }

  void test_validateFunctionName_notIdentifierStart() {
    assertRefactoringStatus(
        validateFunctionName('2newName'), RefactoringProblemSeverity.FATAL,
        expectedMessage:
            'Function name must begin with a lowercase letter or underscore.');
  }

  void test_validateFunctionName_null() {
    assertRefactoringStatus(
        validateFunctionName(null), RefactoringProblemSeverity.FATAL,
        expectedMessage: 'Function name must not be null.');
  }

  void test_validateFunctionName_OK() {
    assertRefactoringStatusOK(validateFunctionName('newName'));
  }

  void test_validateFunctionName_OK_leadingUnderscore() {
    assertRefactoringStatusOK(validateFunctionName('_newName'));
  }

  void test_validateFunctionName_OK_middleUnderscore() {
    assertRefactoringStatusOK(validateFunctionName('new_name'));
  }

  void test_validateFunctionName_pseudoKeyword() {
    _assertWarningBuiltIn(validateFunctionName('yield'));
  }

  void test_validateFunctionName_trailingBlanks() {
    assertRefactoringStatus(
        validateFunctionName('newName '), RefactoringProblemSeverity.FATAL,
        expectedMessage: 'Function name must not start or end with a blank.');
  }

  void test_validateFunctionTypeAliasName_doesNotStartWithLowerCase() {
    assertRefactoringStatus(validateFunctionTypeAliasName('newName'),
        RefactoringProblemSeverity.WARNING,
        expectedMessage:
            'Function type alias name should start with an uppercase letter.');
  }

  void test_validateFunctionTypeAliasName_empty() {
    assertRefactoringStatus(
        validateFunctionTypeAliasName(''), RefactoringProblemSeverity.FATAL,
        expectedMessage: 'Function type alias name must not be empty.');
  }

  void test_validateFunctionTypeAliasName_invalidCharacters() {
    assertRefactoringStatus(validateFunctionTypeAliasName('New-Name'),
        RefactoringProblemSeverity.FATAL,
        expectedMessage: "Function type alias name must not contain \'-\'.");
  }

  void test_validateFunctionTypeAliasName_leadingBlanks() {
    assertRefactoringStatus(validateFunctionTypeAliasName(' NewName'),
        RefactoringProblemSeverity.FATAL,
        expectedMessage:
            'Function type alias name must not start or end with a blank.');
  }

  void test_validateFunctionTypeAliasName_notIdentifierMiddle() {
    assertRefactoringStatus(validateFunctionTypeAliasName('New-Name'),
        RefactoringProblemSeverity.FATAL,
        expectedMessage: "Function type alias name must not contain '-'.");
  }

  void test_validateFunctionTypeAliasName_notIdentifierStart() {
    assertRefactoringStatus(validateFunctionTypeAliasName('newName'),
        RefactoringProblemSeverity.WARNING,
        expectedMessage:
            'Function type alias name should start with an uppercase letter.');
  }

  void test_validateFunctionTypeAliasName_null() {
    assertRefactoringStatus(
        validateFunctionTypeAliasName(null), RefactoringProblemSeverity.FATAL,
        expectedMessage: 'Function type alias name must not be null.');
  }

  void test_validateFunctionTypeAliasName_OK() {
    assertRefactoringStatusOK(validateFunctionTypeAliasName('NewName'));
  }

  void test_validateFunctionTypeAliasName_OK_leadingDollar() {
    assertRefactoringStatusOK(validateFunctionTypeAliasName('\$NewName'));
  }

  void test_validateFunctionTypeAliasName_OK_leadingUnderscore() {
    assertRefactoringStatusOK(validateFunctionTypeAliasName('_NewName'));
  }

  void test_validateFunctionTypeAliasName_OK_middleDollar() {
    assertRefactoringStatusOK(validateFunctionTypeAliasName('New\$Name'));
  }

  void test_validateFunctionTypeAliasName_trailingBlanks() {
    assertRefactoringStatus(validateFunctionTypeAliasName('NewName '),
        RefactoringProblemSeverity.FATAL,
        expectedMessage:
            'Function type alias name must not start or end with a blank.');
  }

  void test_validateImportPrefixName_doesNotStartWithLowerCase() {
    assertRefactoringStatus(
        validateImportPrefixName('NewName'), RefactoringProblemSeverity.WARNING,
        expectedMessage:
            'Import prefix name should start with a lowercase letter.');
  }

  void test_validateImportPrefixName_empty() {
    assertRefactoringStatusOK(validateImportPrefixName(''));
  }

  void test_validateImportPrefixName_keyword() {
    assertRefactoringStatus(
        validateImportPrefixName('while'), RefactoringProblemSeverity.FATAL,
        expectedMessage: 'Import prefix name must not be a keyword.');
  }

  void test_validateImportPrefixName_leadingBlanks() {
    assertRefactoringStatus(
        validateImportPrefixName(' newName'), RefactoringProblemSeverity.FATAL,
        expectedMessage:
            'Import prefix name must not start or end with a blank.');
  }

  void test_validateImportPrefixName_notIdentifierMiddle() {
    assertRefactoringStatus(
        validateImportPrefixName('new-Name'), RefactoringProblemSeverity.FATAL,
        expectedMessage: "Import prefix name must not contain '-'.");
  }

  void test_validateImportPrefixName_notIdentifierStart() {
    assertRefactoringStatus(
        validateImportPrefixName('2newName'), RefactoringProblemSeverity.FATAL,
        expectedMessage:
            'Import prefix name must begin with a lowercase letter or underscore.');
  }

  void test_validateImportPrefixName_null() {
    assertRefactoringStatus(
        validateImportPrefixName(null), RefactoringProblemSeverity.FATAL,
        expectedMessage: 'Import prefix name must not be null.');
  }

  void test_validateImportPrefixName_OK() {
    assertRefactoringStatusOK(validateImportPrefixName('newName'));
  }

  void test_validateImportPrefixName_OK_leadingUnderscore() {
    assertRefactoringStatusOK(validateImportPrefixName('_newName'));
  }

  void test_validateImportPrefixName_OK_middleUnderscore() {
    assertRefactoringStatusOK(validateImportPrefixName('new_name'));
  }

  void test_validateImportPrefixName_pseudoKeyword() {
    assertRefactoringStatus(
        validateImportPrefixName('await'), RefactoringProblemSeverity.FATAL,
        expectedMessage: 'Import prefix name must not be a keyword.');
  }

  void test_validateImportPrefixName_trailingBlanks() {
    assertRefactoringStatus(
        validateImportPrefixName('newName '), RefactoringProblemSeverity.FATAL,
        expectedMessage:
            'Import prefix name must not start or end with a blank.');
  }

  void test_validateLabelName_doesNotStartWithLowerCase() {
    assertRefactoringStatus(
        validateLabelName('NewName'), RefactoringProblemSeverity.WARNING,
        expectedMessage: 'Label name should start with a lowercase letter.');
  }

  void test_validateLabelName_empty() {
    assertRefactoringStatus(
        validateLabelName(''), RefactoringProblemSeverity.FATAL,
        expectedMessage: 'Label name must not be empty.');
  }

  void test_validateLabelName_keyword() {
    assertRefactoringStatus(
        validateLabelName('for'), RefactoringProblemSeverity.FATAL,
        expectedMessage: 'Label name must not be a keyword.');
  }

  void test_validateLabelName_leadingBlanks() {
    assertRefactoringStatus(
        validateLabelName(' newName'), RefactoringProblemSeverity.FATAL,
        expectedMessage: 'Label name must not start or end with a blank.');
  }

  void test_validateLabelName_notIdentifierMiddle() {
    assertRefactoringStatus(
        validateLabelName('new-Name'), RefactoringProblemSeverity.FATAL,
        expectedMessage: "Label name must not contain '-'.");
  }

  void test_validateLabelName_notIdentifierStart() {
    assertRefactoringStatus(
        validateLabelName('2newName'), RefactoringProblemSeverity.FATAL,
        expectedMessage:
            'Label name must begin with a lowercase letter or underscore.');
  }

  void test_validateLabelName_null() {
    assertRefactoringStatus(
        validateLabelName(null), RefactoringProblemSeverity.FATAL,
        expectedMessage: 'Label name must not be null.');
  }

  void test_validateLabelName_OK() {
    assertRefactoringStatusOK(validateLabelName('newName'));
  }

  void test_validateLabelName_OK_leadingDollar() {
    assertRefactoringStatusOK(validateLabelName('\$newName'));
  }

  void test_validateLabelName_OK_leadingUnderscore() {
    assertRefactoringStatusOK(validateLabelName('_newName'));
  }

  void test_validateLabelName_OK_middleUnderscore() {
    assertRefactoringStatusOK(validateLabelName('new_name'));
  }

  void test_validateLabelName_pseudoKeyword() {
    _assertWarningBuiltIn(validateLabelName('await'));
  }

  void test_validateLabelName_trailingBlanks() {
    assertRefactoringStatus(
        validateLabelName('newName '), RefactoringProblemSeverity.FATAL,
        expectedMessage: 'Label name must not start or end with a blank.');
  }

  void test_validateLibraryName_blank() {
    assertRefactoringStatus(
        validateLibraryName(''), RefactoringProblemSeverity.FATAL,
        expectedMessage: 'Library name must not be blank.');
    assertRefactoringStatus(
        validateLibraryName(' '), RefactoringProblemSeverity.FATAL,
        expectedMessage: 'Library name must not be blank.');
  }

  void test_validateLibraryName_blank_identifier() {
    assertRefactoringStatus(
        validateLibraryName('my..name'), RefactoringProblemSeverity.FATAL,
        expectedMessage: 'Library name identifier must not be empty.');
    assertRefactoringStatus(
        validateLibraryName('my. .name'), RefactoringProblemSeverity.FATAL,
        expectedMessage:
            'Library name identifier must not start or end with a blank.');
  }

  void test_validateLibraryName_hasUpperCase() {
    assertRefactoringStatus(
        validateLibraryName('my.newName'), RefactoringProblemSeverity.WARNING,
        expectedMessage:
            'Library name should consist of lowercase identifier separated by dots.');
  }

  void test_validateLibraryName_keyword() {
    assertRefactoringStatus(
        validateLibraryName('my.for.name'), RefactoringProblemSeverity.FATAL,
        expectedMessage: 'Library name identifier must not be a keyword.');
  }

  void test_validateLibraryName_leadingBlanks() {
    assertRefactoringStatus(
        validateLibraryName('my. name'), RefactoringProblemSeverity.FATAL,
        expectedMessage:
            'Library name identifier must not start or end with a blank.');
  }

  void test_validateLibraryName_notIdentifierMiddle() {
    assertRefactoringStatus(
        validateLibraryName('my.ba-d.name'), RefactoringProblemSeverity.FATAL,
        expectedMessage: "Library name identifier must not contain '-'.");
  }

  void test_validateLibraryName_notIdentifierStart() {
    assertRefactoringStatus(
        validateLibraryName('my.2bad.name'), RefactoringProblemSeverity.FATAL,
        expectedMessage:
            'Library name identifier must begin with a lowercase letter or underscore.');
  }

  void test_validateLibraryName_null() {
    assertRefactoringStatus(
        validateLibraryName(null), RefactoringProblemSeverity.FATAL,
        expectedMessage: 'Library name must not be null.');
  }

  void test_validateLibraryName_OK_oneIdentifier() {
    assertRefactoringStatusOK(validateLibraryName('name'));
  }

  void test_validateLibraryName_OK_severalIdentifiers() {
    assertRefactoringStatusOK(validateLibraryName('my.lib.name'));
  }

  void test_validateLibraryName_trailingBlanks() {
    assertRefactoringStatus(
        validateLibraryName('my.bad .name'), RefactoringProblemSeverity.FATAL,
        expectedMessage:
            'Library name identifier must not start or end with a blank.');
  }

  void test_validateMethodName_doesNotStartWithLowerCase() {
    assertRefactoringStatus(
        validateMethodName('NewName'), RefactoringProblemSeverity.WARNING,
        expectedMessage: 'Method name should start with a lowercase letter.');
  }

  void test_validateMethodName_empty() {
    assertRefactoringStatus(
        validateMethodName(''), RefactoringProblemSeverity.FATAL,
        expectedMessage: 'Method name must not be empty.');
  }

  void test_validateMethodName_keyword() {
    assertRefactoringStatus(
        validateMethodName('for'), RefactoringProblemSeverity.FATAL,
        expectedMessage: 'Method name must not be a keyword.');
  }

  void test_validateMethodName_leadingBlanks() {
    assertRefactoringStatus(
        validateMethodName(' newName'), RefactoringProblemSeverity.FATAL,
        expectedMessage: 'Method name must not start or end with a blank.');
  }

  void test_validateMethodName_notIdentifierMiddle() {
    assertRefactoringStatus(
        validateMethodName('new-Name'), RefactoringProblemSeverity.FATAL,
        expectedMessage: "Method name must not contain '-'.");
  }

  void test_validateMethodName_notIdentifierStart() {
    assertRefactoringStatus(
        validateMethodName('2newName'), RefactoringProblemSeverity.FATAL,
        expectedMessage:
            'Method name must begin with a lowercase letter or underscore.');
  }

  void test_validateMethodName_null() {
    assertRefactoringStatus(
        validateMethodName(null), RefactoringProblemSeverity.FATAL,
        expectedMessage: 'Method name must not be null.');
  }

  void test_validateMethodName_OK() {
    assertRefactoringStatusOK(validateMethodName('newName'));
  }

  void test_validateMethodName_OK_leadingUnderscore() {
    assertRefactoringStatusOK(validateMethodName('_newName'));
  }

  void test_validateMethodName_OK_middleUnderscore() {
    assertRefactoringStatusOK(validateMethodName('new_name'));
  }

  void test_validateMethodName_pseudoKeyword() {
    _assertWarningBuiltIn(validateMethodName('yield'));
  }

  void test_validateMethodName_trailingBlanks() {
    assertRefactoringStatus(
        validateMethodName('newName '), RefactoringProblemSeverity.FATAL,
        expectedMessage: 'Method name must not start or end with a blank.');
  }

  void test_validateParameterName_builtIn() {
    _assertWarningBuiltIn(validateParameterName('await'));
  }

  void test_validateParameterName_doesNotStartWithLowerCase() {
    assertRefactoringStatus(
        validateParameterName('NewName'), RefactoringProblemSeverity.WARNING,
        expectedMessage:
            'Parameter name should start with a lowercase letter.');
  }

  void test_validateParameterName_empty() {
    assertRefactoringStatus(
        validateParameterName(''), RefactoringProblemSeverity.FATAL,
        expectedMessage: 'Parameter name must not be empty.');
  }

  void test_validateParameterName_keyword() {
    assertRefactoringStatus(
        validateParameterName('while'), RefactoringProblemSeverity.FATAL,
        expectedMessage: 'Parameter name must not be a keyword.');
  }

  void test_validateParameterName_leadingBlanks() {
    assertRefactoringStatus(
        validateParameterName(' newName'), RefactoringProblemSeverity.FATAL,
        expectedMessage: 'Parameter name must not start or end with a blank.');
  }

  void test_validateParameterName_notIdentifierMiddle() {
    assertRefactoringStatus(
        validateParameterName('new-Name'), RefactoringProblemSeverity.FATAL,
        expectedMessage: "Parameter name must not contain '-'.");
  }

  void test_validateParameterName_notIdentifierStart() {
    assertRefactoringStatus(
        validateParameterName('2newName'), RefactoringProblemSeverity.FATAL,
        expectedMessage:
            'Parameter name must begin with a lowercase letter or underscore.');
  }

  void test_validateParameterName_null() {
    assertRefactoringStatus(
        validateParameterName(null), RefactoringProblemSeverity.FATAL,
        expectedMessage: 'Parameter name must not be null.');
  }

  void test_validateParameterName_OK() {
    assertRefactoringStatusOK(validateParameterName('newName'));
  }

  void test_validateParameterName_OK_leadingUnderscore() {
    assertRefactoringStatusOK(validateParameterName('_newName'));
  }

  void test_validateParameterName_OK_middleUnderscore() {
    assertRefactoringStatusOK(validateParameterName('new_name'));
  }

  void test_validateParameterName_pseudoKeyword() {
    _assertWarningBuiltIn(validateParameterName('await'));
  }

  void test_validateParameterName_trailingBlanks() {
    assertRefactoringStatus(
        validateParameterName('newName '), RefactoringProblemSeverity.FATAL,
        expectedMessage: 'Parameter name must not start or end with a blank.');
  }

  void test_validateVariableName_builtIn() {
    _assertWarningBuiltIn(validateVariableName('abstract'));
  }

  void test_validateVariableName_doesNotStartWithLowerCase() {
    assertRefactoringStatus(
        validateVariableName('NewName'), RefactoringProblemSeverity.WARNING,
        expectedMessage: 'Variable name should start with a lowercase letter.');
  }

  void test_validateVariableName_empty() {
    assertRefactoringStatus(
        validateVariableName(''), RefactoringProblemSeverity.FATAL,
        expectedMessage: 'Variable name must not be empty.');
  }

  void test_validateVariableName_keyword() {
    assertRefactoringStatus(
        validateVariableName('for'), RefactoringProblemSeverity.FATAL,
        expectedMessage: 'Variable name must not be a keyword.');
  }

  void test_validateVariableName_leadingBlanks() {
    assertRefactoringStatus(
        validateVariableName(' newName'), RefactoringProblemSeverity.FATAL,
        expectedMessage: 'Variable name must not start or end with a blank.');
  }

  void test_validateVariableName_notIdentifierMiddle() {
    assertRefactoringStatus(
        validateVariableName('new-Name'), RefactoringProblemSeverity.FATAL,
        expectedMessage: "Variable name must not contain '-'.");
  }

  void test_validateVariableName_notIdentifierStart() {
    assertRefactoringStatus(
        validateVariableName('2newName'), RefactoringProblemSeverity.FATAL,
        expectedMessage:
            'Variable name must begin with a lowercase letter or underscore.');
  }

  void test_validateVariableName_null() {
    assertRefactoringStatus(
        validateVariableName(null), RefactoringProblemSeverity.FATAL,
        expectedMessage: 'Variable name must not be null.');
  }

  void test_validateVariableName_OK() {
    assertRefactoringStatusOK(validateVariableName('newName'));
  }

  void test_validateVariableName_OK_leadingDollar() {
    assertRefactoringStatusOK(validateVariableName('\$newName'));
  }

  void test_validateVariableName_OK_leadingUnderscore() {
    assertRefactoringStatusOK(validateVariableName('_newName'));
  }

  void test_validateVariableName_OK_middleUnderscore() {
    assertRefactoringStatusOK(validateVariableName('new_name'));
  }

  void test_validateVariableName_pseudoKeyword() {
    _assertWarningBuiltIn(validateVariableName('await'));
  }

  void test_validateVariableName_trailingBlanks() {
    assertRefactoringStatus(
        validateVariableName('newName '), RefactoringProblemSeverity.FATAL,
        expectedMessage: 'Variable name must not start or end with a blank.');
  }

  void _assertWarningBuiltIn(RefactoringStatus status) {
    assertRefactoringStatus(status, RefactoringProblemSeverity.WARNING,
        expectedMessage: 'Avoid using built-in identifiers as names.');
  }
}