// 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.

#library('QueryTest');
#import('../../pkg/unittest/unittest.dart');
#import('../../pkg/unittest/html_config.dart');
#import('dart:html');

main() {
  useHtmlConfiguration();

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

  test('query', () {
      Element e = query('#testcanvas');
      Expect.isNotNull(e);
      Expect.stringEquals('testcanvas', e.id);
      Expect.isTrue(e is CanvasElement);
      Expect.equals(canvas, e);
    });

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

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


  test('queryAll (Multiple)', () {
      List l = queryAll('img');
      Expect.equals(2, l.length);
      Expect.isTrue(l[0] is ImageElement);
      Expect.isTrue(l[1] is ImageElement);
      Expect.notEquals(l[0], l[1]);
    });

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