// Copyright (c) 2011, 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 'dart:html';

import 'package:expect/minitest.dart';

main() {
  final div = new DivElement();
  final canvas = new CanvasElement(width: 200, height: 200);
  canvas.id = 'testcanvas';
  final element = new Element.html("<div><br/><img/><input/><img/></div>");
  document.body.nodes.addAll([div, canvas, element]);

  var isCanvasElement =
      predicate((x) => x is CanvasElement, 'is a CanvasElement');
  var isImageElement =
      predicate((x) => x is ImageElement, 'is an ImageElement');

  test('query', () {
    Element e = query('#testcanvas');
    expect(e, isNotNull);
    expect(e.id, 'testcanvas');
    expect(e, isCanvasElement);
    expect(e, canvas);
  });

  test('query (None)', () {
    Element e = query('#nothere');
    expect(e, isNull);
  });

  test('queryAll (One)', () {
    List l = queryAll('canvas');
    expect(l.length, 1);
    expect(l[0], canvas);
  });

  test('queryAll (Multiple)', () {
    List l = queryAll('img');
    expect(l.length, 2);
    expect(l[0], isImageElement);
    expect(l[1], isImageElement);
    expect(l[0] == l[1], isFalse);
  });

  test('queryAll (None)', () {
    List l = queryAll('video');
    expect(l.isEmpty, isTrue);
  });
}
