/*
 * Copyright (c) 2015, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 * 
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.
 * 
 * This code is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 * version 2 for more details (a copy is included in the LICENSE file that
 * accompanied this code).
 * 
 * You should have received a copy of the GNU General Public License version
 * 2 along with this work; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 * 
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
 * or visit www.oracle.com if you need additional information or have any
 * questions.
 */

/**
 * JDK-8141702: Add support for Symbol property keys
 *
 * @test
 * @run
 * @option --language=es6
 */

Assert.assertTrue(typeof Symbol === 'function');
Assert.assertTrue(typeof Symbol() === 'symbol');

Assert.assertTrue(Symbol().toString() === 'Symbol()');
Assert.assertTrue(Symbol('foo').toString() === 'Symbol(foo)');
Assert.assertTrue(Symbol(1).toString() === 'Symbol(1)');
Assert.assertTrue(Symbol(true).toString() === 'Symbol(true)');
Assert.assertTrue(Symbol([1, 2, 3]).toString() === 'Symbol(1,2,3)');
Assert.assertTrue(Symbol(null).toString() === 'Symbol(null)');
Assert.assertTrue(Symbol(undefined).toString() === 'Symbol()');

const s1 = Symbol();
const s2 = Symbol("s2");
Assert.assertFalse(s1 instanceof Symbol); // not an object

let obj = {};
obj['foo'] = 'foo';
obj[s1] = s1;
obj['bar'] = 'bar';
obj[1] = 1;
obj[s2] = s2;

Assert.assertTrue(obj['foo'] === 'foo');
Assert.assertTrue(obj[s1] === s1);
Assert.assertTrue(obj['bar'] === 'bar');
Assert.assertTrue(obj[1] === 1);
Assert.assertTrue(obj[s2] === s2);

const expectedNames = ['1', 'foo', 'bar'];
const expectedSymbols = [s1, s2];
const actualNames = Object.getOwnPropertyNames(obj);
let actualSymbols = Object.getOwnPropertySymbols(obj);
Assert.assertTrue(expectedNames.length == actualNames.length);
Assert.assertTrue(expectedSymbols.length == actualSymbols.length);

for (let key in expectedNames) {
    Assert.assertTrue(expectedNames[key] === actualNames[key]);
}
for (let key in expectedSymbols) {
    Assert.assertTrue(expectedSymbols[key] === actualSymbols[key]);
}

// Delete
Assert.assertTrue(delete obj[s1]);
Assert.assertTrue(Object.getOwnPropertySymbols(obj).length === 1);
Assert.assertTrue(Object.getOwnPropertySymbols(obj)[0] === s2);

// Object.defineProperty
Object.defineProperty(obj, s1, {value : 'hello'});
Assert.assertTrue(obj[s1] === 'hello');
actualSymbols = Object.getOwnPropertySymbols(obj);
Assert.assertTrue(Object.getOwnPropertySymbols(obj).length === 2);
Assert.assertTrue(Object.getOwnPropertySymbols(obj)[1] === s1);

// Symbol called as constructor
try {
    new Symbol();
    Assert.fail("Symbol invoked as constructor");
} catch (e) {
    if (e.name !== "TypeError" || e.message !== "Symbol is not a constructor.") {
        Assert.fail("Unexpected error: " + e);
    }
}

// Implicit conversion to string or number should throw
try {
    ' ' + s1;
    Assert.fail("Symbol converted to string");
} catch (e) {
    if (e.name !== "TypeError" || e.message !== "Can not convert Symbol value to string.") {
        Assert.fail("Unexpected error: " + e);
    }
}

try {
    4 * s1;
    Assert.fail("Symbol converted to number");
} catch (e) {
    if (e.name !== "TypeError" || e.message !== "Can not convert Symbol value to number.") {
        Assert.fail("Unexpected error: " + e);
    }
}

// Symbol.for and Symbol.keyFor

const uncached = Symbol('foo');
const cached = Symbol.for('foo');

Assert.assertTrue(uncached !== cached);
Assert.assertTrue(Symbol.keyFor(uncached) === undefined);
Assert.assertTrue(Symbol.keyFor(cached) === 'foo');
Assert.assertTrue(cached === Symbol.for('foo'));
Assert.assertTrue(cached === Symbol.for('f' + 'oo'));

// JDK-8147008: Make sure symbols are handled by primitive linker
Symbol.prototype.foo = 123;
Symbol.prototype[s2] = s2;
Assert.assertEquals(s1.foo, 123);
Assert.assertEquals(s2[s2], s2);

// Object wrapper

const o = Object(s1);
obj = {};
obj[s1] = "s1";
Assert.assertTrue(o == s1);
Assert.assertTrue(o !== s1);
Assert.assertTrue(typeof o === 'object');
Assert.assertTrue(o instanceof Symbol);
Assert.assertTrue(obj[o] == 's1');
Assert.assertTrue(o in obj);
Assert.assertEquals(o.foo, 123);
Assert.assertEquals(o[s2], s2);

// various non-strict comparisons that should fail

Assert.assertFalse(0 == Symbol());
Assert.assertFalse(1 == Symbol(1));
Assert.assertFalse(null == Symbol());
Assert.assertFalse(undefined == Symbol);
Assert.assertFalse('Symbol()' == Symbol());
Assert.assertFalse('Symbol(foo)' == Symbol('foo'));