Using official driver

Jint.Tests.Ecma/EcmaTest.cs

@@ -20,38 +20,23 @@ namespace Jint.Tests.Ecma
 
         }
 
-        private const string Driver = @"
-            function fnGlobalObject() {
-                return Function('return this')();
-            }
+        protected void RunTestCode(string code, bool negative)
+        {
+            _lastError = null;
 
-            function runTestCase(f) {
-                if(!f()) $ERROR('');
-            }
-        ";
+            var engine = new Engine();
 
-        private const string NegativeDriver = @"
-            function fnGlobalObject() {
-                return Function('return this')();
-            }
 
-            function runTestCase(f) {
-                if(f()) $ERROR('');
-            }
-        ";
+            // loading driver
+
+            var driverFilename = Path.Combine(BasePath, "TestCases\\sta.js");
+            engine.Execute(File.ReadAllText(driverFilename));
 
-        protected void RunTestCode(string code, bool negative)
-        {
-            _lastError = null; 
-            
-            var engine = new Engine(cfg => cfg
-                    .WithDelegate("$ERROR", Error)
-                );
             if (negative)
             {
                 try
                 {
-                    engine.Execute(code + Environment.NewLine + NegativeDriver);
+                    engine.Execute(code);
                     Assert.True(_lastError != null);
                     Assert.False(true);
                 }
@@ -63,7 +48,7 @@ namespace Jint.Tests.Ecma
             }
             else
             {
-                Assert.DoesNotThrow(() => engine.Execute(code + Environment.NewLine + Driver));
+                Assert.DoesNotThrow(() => engine.Execute(code));
                 Assert.Null(_lastError);
             }
         }

Jint.Tests.Ecma/Jint.Tests.Ecma.csproj

@@ -37,11 +37,13 @@
     <Reference Include="Microsoft.CSharp" />
     <Reference Include="System.Data" />
     <Reference Include="System.Xml" />
-    <Reference Include="xunit">
-      <HintPath>..\packages\xunit.1.9.1\lib\net20\xunit.dll</HintPath>
+    <Reference Include="xunit, Version=1.9.2.1705, Culture=neutral, PublicKeyToken=8d05b1bb7a6fdb6c, processorArchitecture=MSIL">
+      <SpecificVersion>False</SpecificVersion>
+      <HintPath>..\packages\xunit.1.9.2\lib\net20\xunit.dll</HintPath>
     </Reference>
-    <Reference Include="xunit.extensions">
-      <HintPath>..\packages\xunit.extensions.1.9.1\lib\net20\xunit.extensions.dll</HintPath>
+    <Reference Include="xunit.extensions, Version=1.9.2.1705, Culture=neutral, PublicKeyToken=8d05b1bb7a6fdb6c, processorArchitecture=MSIL">
+      <SpecificVersion>False</SpecificVersion>
+      <HintPath>..\packages\xunit.extensions.1.9.2\lib\net20\xunit.extensions.dll</HintPath>
     </Reference>
   </ItemGroup>
   <ItemGroup>
@@ -456,9 +458,6 @@
     <Compile Include="Ecma\9.9.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
   </ItemGroup>
-  <ItemGroup>
-    <None Include="packages.config" />
-  </ItemGroup>
   <ItemGroup>
     <ProjectReference Include="..\Jint\Jint.csproj">
       <Project>{a2707cfd-e37d-4b88-8fc2-238d4c1dfd01}</Project>
@@ -12032,6 +12031,10 @@
     <Content Include="TestCases\ch15\15.9\15.9.5\S15.9.5_A40_T1.js" />
     <Content Include="TestCases\ch15\15.9\15.9.5\S15.9.5_A41_T1.js" />
     <Content Include="TestCases\ch15\15.9\15.9.5\S15.9.5_A42_T1.js" />
+    <Content Include="TestCases\sta.js" />
+  </ItemGroup>
+  <ItemGroup>
+    <None Include="packages.config" />
   </ItemGroup>
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
   <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 

Jint.Tests.Ecma/TestCases/sta.js

@@ -0,0 +1,901 @@
+/// Copyright (c) 2012 Ecma International.  All rights reserved. 
+/// Ecma International makes this code available under the terms and conditions set
+/// forth on http://hg.ecmascript.org/tests/test262/raw-file/tip/LICENSE (the 
+/// "Use Terms").   Any redistribution of this code must retain the above 
+/// copyright and this notice and otherwise comply with the Use Terms.
+
+//-----------------------------------------------------------------------------
+function compareArray(aExpected, aActual) {
+    if (aActual.length != aExpected.length) {
+        return false;
+    }
+
+    aExpected.sort();
+    aActual.sort();
+
+    var s;
+    for (var i = 0; i < aExpected.length; i++) {
+        if (aActual[i] !== aExpected[i]) {
+            return false;
+        }
+    }
+    return true;
+}
+
+//-----------------------------------------------------------------------------
+function arrayContains(arr, expected) {
+    var found;
+    for (var i = 0; i < expected.length; i++) {
+        found = false;
+        for (var j = 0; j < arr.length; j++) {
+            if (expected[i] === arr[j]) {
+                found = true;
+                break;
+            }
+        }
+        if (!found) {
+            return false;
+        }
+    }
+    return true;
+}
+
+//-----------------------------------------------------------------------------
+var supportsArrayIndexGettersOnArrays = undefined;
+function fnSupportsArrayIndexGettersOnArrays() {
+    if (typeof supportsArrayIndexGettersOnArrays !== "undefined") {
+        return supportsArrayIndexGettersOnArrays;
+    }
+
+    supportsArrayIndexGettersOnArrays = false;
+
+    if (fnExists(Object.defineProperty)) {
+        var arr = [];
+        Object.defineProperty(arr, "0", {
+            get: function () {
+                supportsArrayIndexGettersOnArrays = true;
+                return 0;
+            }
+        });
+        var res = arr[0];
+    }
+
+    return supportsArrayIndexGettersOnArrays;
+}
+
+//-----------------------------------------------------------------------------
+var supportsArrayIndexGettersOnObjects = undefined;
+function fnSupportsArrayIndexGettersOnObjects() {
+    if (typeof supportsArrayIndexGettersOnObjects !== "undefined")
+        return supportsArrayIndexGettersOnObjects;
+
+    supportsArrayIndexGettersOnObjects = false;
+
+    if (fnExists(Object.defineProperty)) {
+        var obj = {};
+        Object.defineProperty(obj, "0", {
+            get: function () {
+                supportsArrayIndexGettersOnObjects = true;
+                return 0;
+            }
+        });
+        var res = obj[0];
+    }
+
+    return supportsArrayIndexGettersOnObjects;
+}
+
+//-----------------------------------------------------------------------------
+function ConvertToFileUrl(pathStr) {
+    return "file:" + pathStr.replace(/\\/g, "/");
+}
+
+//-----------------------------------------------------------------------------
+function fnExists(/*arguments*/) {
+    for (var i = 0; i < arguments.length; i++) {
+        if (typeof (arguments[i]) !== "function") return false;
+    }
+    return true;
+}
+
+//-----------------------------------------------------------------------------
+var __globalObject = Function("return this;")();
+function fnGlobalObject() {
+    return __globalObject;
+}
+
+//-----------------------------------------------------------------------------
+function fnSupportsStrict() {
+    "use strict";
+    try {
+        eval('with ({}) {}');
+        return false;
+    } catch (e) {
+        return true;
+    }
+}
+
+//-----------------------------------------------------------------------------
+//Verify all attributes specified data property of given object:
+//value, writable, enumerable, configurable
+//If all attribute values are expected, return true, otherwise, return false
+function dataPropertyAttributesAreCorrect(obj,
+                                          name,
+                                          value,
+                                          writable,
+                                          enumerable,
+                                          configurable) {
+    var attributesCorrect = true;
+
+    if (obj[name] !== value) {
+        if (typeof obj[name] === "number" &&
+            isNaN(obj[name]) &&
+            typeof value === "number" &&
+            isNaN(value)) {
+            // keep empty
+        } else {
+            attributesCorrect = false;
+        }
+    }
+
+    try {
+        if (obj[name] === "oldValue") {
+            obj[name] = "newValue";
+        } else {
+            obj[name] = "OldValue";
+        }
+    } catch (we) {
+    }
+
+    var overwrited = false;
+    if (obj[name] !== value) {
+        if (typeof obj[name] === "number" &&
+            isNaN(obj[name]) &&
+            typeof value === "number" &&
+            isNaN(value)) {
+            // keep empty
+        } else {
+            overwrited = true;
+        }
+    }
+    if (overwrited !== writable) {
+        attributesCorrect = false;
+    }
+
+    var enumerated = false;
+    for (var prop in obj) {
+        if (obj.hasOwnProperty(prop) && prop === name) {
+            enumerated = true;
+        }
+    }
+
+    if (enumerated !== enumerable) {
+        attributesCorrect = false;
+    }
+
+
+    var deleted = false;
+
+    try {
+        delete obj[name];
+    } catch (de) {
+    }
+    if (!obj.hasOwnProperty(name)) {
+        deleted = true;
+    }
+    if (deleted !== configurable) {
+        attributesCorrect = false;
+    }
+
+    return attributesCorrect;
+}
+
+//-----------------------------------------------------------------------------
+//Verify all attributes specified accessor property of given object:
+//get, set, enumerable, configurable
+//If all attribute values are expected, return true, otherwise, return false
+function accessorPropertyAttributesAreCorrect(obj,
+                                              name,
+                                              get,
+                                              set,
+                                              setVerifyHelpProp,
+                                              enumerable,
+                                              configurable) {
+    var attributesCorrect = true;
+
+    if (get !== undefined) {
+        if (obj[name] !== get()) {
+            if (typeof obj[name] === "number" &&
+                isNaN(obj[name]) &&
+                typeof get() === "number" &&
+                isNaN(get())) {
+                // keep empty
+            } else {
+                attributesCorrect = false;
+            }
+        }
+    } else {
+        if (obj[name] !== undefined) {
+            attributesCorrect = false;
+        }
+    }
+
+    try {
+        var desc = Object.getOwnPropertyDescriptor(obj, name);
+        if (typeof desc.set === "undefined") {
+            if (typeof set !== "undefined") {
+                attributesCorrect = false;
+            }
+        } else {
+            obj[name] = "toBeSetValue";
+            if (obj[setVerifyHelpProp] !== "toBeSetValue") {
+                attributesCorrect = false;
+            }
+        }
+    } catch (se) {
+        throw se;
+    }
+
+
+    var enumerated = false;
+    for (var prop in obj) {
+        if (obj.hasOwnProperty(prop) && prop === name) {
+            enumerated = true;
+        }
+    }
+
+    if (enumerated !== enumerable) {
+        attributesCorrect = false;
+    }
+
+
+    var deleted = false;
+    try {
+        delete obj[name];
+    } catch (de) {
+        throw de;
+    }
+    if (!obj.hasOwnProperty(name)) {
+        deleted = true;
+    }
+    if (deleted !== configurable) {
+        attributesCorrect = false;
+    }
+
+    return attributesCorrect;
+}
+
+//-----------------------------------------------------------------------------
+var NotEarlyErrorString = "NotEarlyError";
+var EarlyErrorRePat = "^((?!" + NotEarlyErrorString + ").)*$";
+var NotEarlyError = new Error(NotEarlyErrorString);
+
+//-----------------------------------------------------------------------------
+// Copyright 2009 the Sputnik authors.  All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+function Test262Error(message) {
+    if (message) this.message = message;
+}
+
+Test262Error.prototype.toString = function () {
+    return "Test262 Error: " + this.message;
+};
+
+function testFailed(message) {
+    throw new Test262Error(message);
+}
+
+
+function testPrint(message) {
+
+}
+
+
+//adaptors for Test262 framework
+function $PRINT(message) {
+
+}
+
+function $INCLUDE(message) { }
+function $ERROR(message) {
+    testFailed(message);
+}
+
+function $FAIL(message) {
+    testFailed(message);
+}
+
+
+
+//Sputnik library definitions
+//Ultimately these should be namespaced some how and only made
+//available to tests that explicitly include them.
+//For now, we just define the globally
+
+//math_precision.js
+// Copyright 2009 the Sputnik authors.  All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+function getPrecision(num) {
+    //TODO: Create a table of prec's,
+    //      because using Math for testing Math isn't that correct.
+
+    var log2num = Math.log(Math.abs(num)) / Math.LN2;
+    var pernum = Math.ceil(log2num);
+    return (2 * Math.pow(2, -52 + pernum));
+    //return(0);
+}
+
+
+//math_isequal.js
+// Copyright 2009 the Sputnik authors.  All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+var prec;
+function isEqual(num1, num2) {
+    if ((num1 === Infinity) && (num2 === Infinity)) {
+        return (true);
+    }
+    if ((num1 === -Infinity) && (num2 === -Infinity)) {
+        return (true);
+    }
+    prec = getPrecision(Math.min(Math.abs(num1), Math.abs(num2)));
+    return (Math.abs(num1 - num2) <= prec);
+    //return(num1 === num2);
+}
+
+//numeric_conversion.js
+// Copyright 2009 the Sputnik authors.  All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+function ToInteger(p) {
+    var x = Number(p);
+
+    if (isNaN(x)) {
+        return +0;
+    }
+
+    if ((x === +0)
+  || (x === -0)
+  || (x === Number.POSITIVE_INFINITY)
+  || (x === Number.NEGATIVE_INFINITY)) {
+        return x;
+    }
+
+    var sign = (x < 0) ? -1 : 1;
+
+    return (sign * Math.floor(Math.abs(x)));
+}
+
+//Date_constants.js
+// Copyright 2009 the Sputnik authors.  All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+var HoursPerDay = 24;
+var MinutesPerHour = 60;
+var SecondsPerMinute = 60;
+
+var msPerDay = 86400000;
+var msPerSecond = 1000;
+var msPerMinute = 60000;
+var msPerHour = 3600000;
+
+var date_1899_end = -2208988800001;
+var date_1900_start = -2208988800000;
+var date_1969_end = -1;
+var date_1970_start = 0;
+var date_1999_end = 946684799999;
+var date_2000_start = 946684800000;
+var date_2099_end = 4102444799999;
+var date_2100_start = 4102444800000;
+
+// Copyright 2009 the Sputnik authors.  All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+//the following values are normally generated by the sputnik.py driver
+var $LocalTZ,
+    $DST_start_month,
+    $DST_start_sunday,
+    $DST_start_hour,
+    $DST_start_minutes,
+    $DST_end_month,
+    $DST_end_sunday,
+    $DST_end_hour,
+    $DST_end_minutes;
+
+(function () {
+    /**
+      * Finds the first date, starting from |start|, where |predicate|
+      * holds.
+      */
+    var findNearestDateBefore = function (start, predicate) {
+        var current = start;
+        var month = 1000 * 60 * 60 * 24 * 30;
+        for (var step = month; step > 0; step = Math.floor(step / 3)) {
+            if (!predicate(current)) {
+                while (!predicate(current))
+                    current = new Date(current.getTime() + step);
+                current = new Date(current.getTime() - step);
+            }
+        }
+        while (!predicate(current)) {
+            current = new Date(current.getTime() + 1);
+        }
+        return current;
+    };
+
+    var juneDate = new Date(2000, 5, 20, 0, 0, 0, 0);
+    var decemberDate = new Date(2000, 11, 20, 0, 0, 0, 0);
+    var juneOffset = juneDate.getTimezoneOffset();
+    var decemberOffset = decemberDate.getTimezoneOffset();
+    var isSouthernHemisphere = (juneOffset > decemberOffset);
+    var winterTime = isSouthernHemisphere ? juneDate : decemberDate;
+    var summerTime = isSouthernHemisphere ? decemberDate : juneDate;
+
+    var dstStart = findNearestDateBefore(winterTime, function (date) {
+        return date.getTimezoneOffset() == summerTime.getTimezoneOffset();
+    });
+    $DST_start_month = dstStart.getMonth();
+    $DST_start_sunday = dstStart.getDate() > 15 ? '"last"' : '"first"';
+    $DST_start_hour = dstStart.getHours();
+    $DST_start_minutes = dstStart.getMinutes();
+
+    var dstEnd = findNearestDateBefore(summerTime, function (date) {
+        return date.getTimezoneOffset() == winterTime.getTimezoneOffset();
+    });
+    $DST_end_month = dstEnd.getMonth();
+    $DST_end_sunday = dstEnd.getDate() > 15 ? '"last"' : '"first"';
+    $DST_end_hour = dstEnd.getHours();
+    $DST_end_minutes = dstEnd.getMinutes();
+
+    return;
+})();
+
+
+//Date.library.js
+// Copyright 2009 the Sputnik authors.  All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+//15.9.1.2 Day Number and Time within Day
+function Day(t) {
+    return Math.floor(t / msPerDay);
+}
+
+function TimeWithinDay(t) {
+    return t % msPerDay;
+}
+
+//15.9.1.3 Year Number
+function DaysInYear(y) {
+    if (y % 4 != 0) return 365;
+    if (y % 4 == 0 && y % 100 != 0) return 366;
+    if (y % 100 == 0 && y % 400 != 0) return 365;
+    if (y % 400 == 0) return 366;
+}
+
+function DayFromYear(y) {
+    return (365 * (y - 1970)
+            + Math.floor((y - 1969) / 4)
+            - Math.floor((y - 1901) / 100)
+            + Math.floor((y - 1601) / 400));
+}
+
+function TimeFromYear(y) {
+    return msPerDay * DayFromYear(y);
+}
+
+function YearFromTime(t) {
+    t = Number(t);
+    var sign = (t < 0) ? -1 : 1;
+    var year = (sign < 0) ? 1969 : 1970;
+
+    for (var time = 0; ; year += sign) {
+        time = TimeFromYear(year);
+
+        if (sign > 0 && time > t) {
+            year -= sign;
+            break;
+        }
+        else if (sign < 0 && time <= t) {
+            break;
+        }
+    };
+    return year;
+}
+
+function InLeapYear(t) {
+    if (DaysInYear(YearFromTime(t)) == 365)
+        return 0;
+
+    if (DaysInYear(YearFromTime(t)) == 366)
+        return 1;
+}
+
+function DayWithinYear(t) {
+    return Day(t) - DayFromYear(YearFromTime(t));
+}
+
+//15.9.1.4 Month Number
+function MonthFromTime(t) {
+    var day = DayWithinYear(t);
+    var leap = InLeapYear(t);
+
+    if ((0 <= day) && (day < 31)) return 0;
+    if ((31 <= day) && (day < (59 + leap))) return 1;
+    if (((59 + leap) <= day) && (day < (90 + leap))) return 2;
+    if (((90 + leap) <= day) && (day < (120 + leap))) return 3;
+    if (((120 + leap) <= day) && (day < (151 + leap))) return 4;
+    if (((151 + leap) <= day) && (day < (181 + leap))) return 5;
+    if (((181 + leap) <= day) && (day < (212 + leap))) return 6;
+    if (((212 + leap) <= day) && (day < (243 + leap))) return 7;
+    if (((243 + leap) <= day) && (day < (273 + leap))) return 8;
+    if (((273 + leap) <= day) && (day < (304 + leap))) return 9;
+    if (((304 + leap) <= day) && (day < (334 + leap))) return 10;
+    if (((334 + leap) <= day) && (day < (365 + leap))) return 11;
+}
+
+//15.9.1.5 Date Number
+function DateFromTime(t) {
+    var day = DayWithinYear(t);
+    var month = MonthFromTime(t);
+    var leap = InLeapYear(t);
+
+    if (month == 0) return day + 1;
+    if (month == 1) return day - 30;
+    if (month == 2) return day - 58 - leap;
+    if (month == 3) return day - 89 - leap;
+    if (month == 4) return day - 119 - leap;
+    if (month == 5) return day - 150 - leap;
+    if (month == 6) return day - 180 - leap;
+    if (month == 7) return day - 211 - leap;
+    if (month == 8) return day - 242 - leap;
+    if (month == 9) return day - 272 - leap;
+    if (month == 10) return day - 303 - leap;
+    if (month == 11) return day - 333 - leap;
+}
+
+//15.9.1.6 Week Day
+function WeekDay(t) {
+    var weekday = (Day(t) + 4) % 7;
+    return (weekday < 0 ? 7 + weekday : weekday);
+}
+
+//15.9.1.9 Daylight Saving Time Adjustment
+$LocalTZ = (new Date()).getTimezoneOffset() / -60;
+if (DaylightSavingTA((new Date()).valueOf()) !== 0) {
+    $LocalTZ -= 1;
+}
+var LocalTZA = $LocalTZ * msPerHour;
+
+function DaysInMonth(m, leap) {
+    m = m % 12;
+
+    //April, June, Sept, Nov
+    if (m == 3 || m == 5 || m == 8 || m == 10) {
+        return 30;
+    }
+
+    //Jan, March, May, July, Aug, Oct, Dec
+    if (m == 0 || m == 2 || m == 4 || m == 6 || m == 7 || m == 9 || m == 11) {
+        return 31;
+    }
+
+    //Feb
+    return 28 + leap;
+}
+
+function GetSundayInMonth(t, m, count) {
+    var year = YearFromTime(t);
+    var tempDate;
+
+    if (count === '"first"') {
+        for (var d = 1; d <= DaysInMonth(m, InLeapYear(t)) ; d++) {
+            tempDate = new Date(year, m, d);
+            if (tempDate.getDay() === 0) {
+                return tempDate.valueOf();
+            }
+        }
+    } else if (count === '"last"') {
+        for (var d = DaysInMonth(m, InLeapYear(t)) ; d > 0; d--) {
+            tempDate = new Date(year, m, d);
+            if (tempDate.getDay() === 0) {
+                return tempDate.valueOf();
+            }
+        }
+    }
+    throw new Error("Unsupported 'count' arg:" + count);
+}
+/*
+function GetSundayInMonth(t, m, count){
+  var year = YearFromTime(t);
+  var leap = InLeapYear(t);
+  var day = 0;
+
+  if(m >= 1) day += DaysInMonth(0, leap);
+  if(m >= 2) day += DaysInMonth(1, leap);
+  if(m >= 3) day += DaysInMonth(2, leap);
+  if(m >= 4) day += DaysInMonth(3, leap);
+  if(m >= 5) day += DaysInMonth(4, leap);
+  if(m >= 6) day += DaysInMonth(5, leap);
+  if(m >= 7) day += DaysInMonth(6, leap);
+  if(m >= 8) day += DaysInMonth(7, leap);
+  if(m >= 9) day += DaysInMonth(8, leap);
+  if(m >= 10) day += DaysInMonth(9, leap);
+  if(m >= 11) day += DaysInMonth(10, leap);
+
+  var month_start = TimeFromYear(year)+day*msPerDay;
+  var sunday = 0;
+
+  if(count === "last"){
+    for(var last_sunday = month_start+DaysInMonth(m, leap)*msPerDay;
+      WeekDay(last_sunday)>0;
+      last_sunday -= msPerDay
+    ){};
+    sunday = last_sunday;
+  }
+  else {
+    for(var first_sunday = month_start;
+      WeekDay(first_sunday)>0;
+      first_sunday += msPerDay
+    ){};
+    sunday = first_sunday+7*msPerDay*(count-1);
+  }
+
+  return sunday;
+}*/
+
+function DaylightSavingTA(t) {
+    //  t = t-LocalTZA;
+
+    var DST_start = GetSundayInMonth(t, $DST_start_month, $DST_start_sunday) +
+                    $DST_start_hour * msPerHour +
+                    $DST_start_minutes * msPerMinute;
+
+    var k = new Date(DST_start);
+
+    var DST_end = GetSundayInMonth(t, $DST_end_month, $DST_end_sunday) +
+                    $DST_end_hour * msPerHour +
+                    $DST_end_minutes * msPerMinute;
+
+    if (t >= DST_start && t < DST_end) {
+        return msPerHour;
+    } else {
+        return 0;
+    }
+}
+
+//15.9.1.9 Local Time
+function LocalTime(t) {
+    return t + LocalTZA + DaylightSavingTA(t);
+}
+
+function UTC(t) {
+    return t - LocalTZA - DaylightSavingTA(t - LocalTZA);
+}
+
+//15.9.1.10 Hours, Minutes, Second, and Milliseconds
+function HourFromTime(t) {
+    return Math.floor(t / msPerHour) % HoursPerDay;
+}
+
+function MinFromTime(t) {
+    return Math.floor(t / msPerMinute) % MinutesPerHour;
+}
+
+function SecFromTime(t) {
+    return Math.floor(t / msPerSecond) % SecondsPerMinute;
+}
+
+function msFromTime(t) {
+    return t % msPerSecond;
+}
+
+//15.9.1.11 MakeTime (hour, min, sec, ms)
+function MakeTime(hour, min, sec, ms) {
+    if (!isFinite(hour) || !isFinite(min) || !isFinite(sec) || !isFinite(ms)) {
+        return Number.NaN;
+    }
+
+    hour = ToInteger(hour);
+    min = ToInteger(min);
+    sec = ToInteger(sec);
+    ms = ToInteger(ms);
+
+    return ((hour * msPerHour) + (min * msPerMinute) + (sec * msPerSecond) + ms);
+}
+
+//15.9.1.12 MakeDay (year, month, date)
+function MakeDay(year, month, date) {
+    if (!isFinite(year) || !isFinite(month) || !isFinite(date)) {
+        return Number.NaN;
+    }
+
+    year = ToInteger(year);
+    month = ToInteger(month);
+    date = ToInteger(date);
+
+    var result5 = year + Math.floor(month / 12);
+    var result6 = month % 12;
+
+    var sign = (year < 1970) ? -1 : 1;
+    var t = (year < 1970) ? 1 : 0;
+    var y = (year < 1970) ? 1969 : 1970;
+
+    if (sign == -1) {
+        for (y = 1969; y >= year; y += sign) {
+            t += sign * DaysInYear(y) * msPerDay;
+        }
+    } else {
+        for (y = 1970 ; y < year; y += sign) {
+            t += sign * DaysInYear(y) * msPerDay;
+        }
+    }
+
+    var leap = 0;
+    for (var m = 0; m < month; m++) {
+        //if year is changed, than we need to recalculate leep
+        leap = InLeapYear(t);
+        t += DaysInMonth(m, leap) * msPerDay;
+    }
+
+    if (YearFromTime(t) != result5) {
+        return Number.NaN;
+    }
+    if (MonthFromTime(t) != result6) {
+        return Number.NaN;
+    }
+    if (DateFromTime(t) != 1) {
+        return Number.NaN;
+    }
+
+    return Day(t) + date - 1;
+}
+
+//15.9.1.13 MakeDate (day, time)
+function MakeDate(day, time) {
+    if (!isFinite(day) || !isFinite(time)) {
+        return Number.NaN;
+    }
+
+    return day * msPerDay + time;
+}
+
+//15.9.1.14 TimeClip (time)
+function TimeClip(time) {
+    if (!isFinite(time) || Math.abs(time) > 8.64e15) {
+        return Number.NaN;
+    }
+
+    return ToInteger(time);
+}
+
+//Test Functions
+//ConstructDate is considered deprecated, and should not be used directly from
+//test262 tests as it's incredibly sensitive to DST start/end dates that 
+//vary with geographic location.
+function ConstructDate(year, month, date, hours, minutes, seconds, ms) {
+    /*
+     * 1. Call ToNumber(year)
+     * 2. Call ToNumber(month)
+     * 3. If date is supplied use ToNumber(date); else use 1
+     * 4. If hours is supplied use ToNumber(hours); else use 0
+     * 5. If minutes is supplied use ToNumber(minutes); else use 0
+     * 6. If seconds is supplied use ToNumber(seconds); else use 0
+     * 7. If ms is supplied use ToNumber(ms); else use 0
+     * 8. If Result(1) is not NaN and 0 <= ToInteger(Result(1)) <= 99, Result(8) is
+     * 1900+ToInteger(Result(1)); otherwise, Result(8) is Result(1)
+     * 9. Compute MakeDay(Result(8), Result(2), Result(3))
+     * 10. Compute MakeTime(Result(4), Result(5), Result(6), Result(7))
+     * 11. Compute MakeDate(Result(9), Result(10))
+     * 12. Set the [[Value]] property of the newly constructed object to TimeClip(UTC(Result(11)))
+     */
+    var r1 = Number(year);
+    var r2 = Number(month);
+    var r3 = ((date && arguments.length > 2) ? Number(date) : 1);
+    var r4 = ((hours && arguments.length > 3) ? Number(hours) : 0);
+    var r5 = ((minutes && arguments.length > 4) ? Number(minutes) : 0);
+    var r6 = ((seconds && arguments.length > 5) ? Number(seconds) : 0);
+    var r7 = ((ms && arguments.length > 6) ? Number(ms) : 0);
+
+    var r8 = r1;
+
+    if (!isNaN(r1) && (0 <= ToInteger(r1)) && (ToInteger(r1) <= 99))
+        r8 = 1900 + r1;
+
+    var r9 = MakeDay(r8, r2, r3);
+    var r10 = MakeTime(r4, r5, r6, r7);
+    var r11 = MakeDate(r9, r10);
+
+    var retVal = TimeClip(UTC(r11));
+    return retVal;
+}
+
+
+
+/**** Python code for initialize the above constants
+// We may want to replicate the following in JavaScript.
+// However, using JS date operations to generate parameters that are then used to
+// test those some date operations seems unsound.  However, it isn't clear if there
+//is a good interoperable alternative.
+
+# Copyright 2009 the Sputnik authors.  All rights reserved.
+# This code is governed by the BSD license found in the LICENSE file.
+
+def GetDaylightSavingsTimes():
+# Is the given floating-point time in DST?
+def IsDst(t):
+return time.localtime(t)[-1]
+# Binary search to find an interval between the two times no greater than
+# delta where DST switches, returning the midpoint.
+def FindBetween(start, end, delta):
+while end - start > delta:
+middle = (end + start) / 2
+if IsDst(middle) == IsDst(start):
+start = middle
+else:
+end = middle
+return (start + end) / 2
+now = time.time()
+one_month = (30 * 24 * 60 * 60)
+# First find a date with different daylight savings.  To avoid corner cases
+# we try four months before and after today.
+after = now + 4 * one_month
+before = now - 4 * one_month
+if IsDst(now) == IsDst(before) and IsDst(now) == IsDst(after):
+logger.warning("Was unable to determine DST info.")
+return None
+# Determine when the change occurs between now and the date we just found
+# in a different DST.
+if IsDst(now) != IsDst(before):
+first = FindBetween(before, now, 1)
+else:
+first = FindBetween(now, after, 1)
+# Determine when the change occurs between three and nine months from the
+# first.
+second = FindBetween(first + 3 * one_month, first + 9 * one_month, 1)
+# Find out which switch is into and which if out of DST
+if IsDst(first - 1) and not IsDst(first + 1):
+start = second
+end = first
+else:
+start = first
+end = second
+return (start, end)
+
+
+def GetDaylightSavingsAttribs():
+times = GetDaylightSavingsTimes()
+if not times:
+return None
+(start, end) = times
+def DstMonth(t):
+return time.localtime(t)[1] - 1
+def DstHour(t):
+return time.localtime(t - 1)[3] + 1
+def DstSunday(t):
+if time.localtime(t)[2] > 15:
+return "'last'"
+else:
+return "'first'"
+def DstMinutes(t):
+return (time.localtime(t - 1)[4] + 1) % 60
+attribs = { }
+attribs['start_month'] = DstMonth(start)
+attribs['end_month'] = DstMonth(end)
+attribs['start_sunday'] = DstSunday(start)
+attribs['end_sunday'] = DstSunday(end)
+attribs['start_hour'] = DstHour(start)
+attribs['end_hour'] = DstHour(end)
+attribs['start_minutes'] = DstMinutes(start)
+attribs['end_minutes'] = DstMinutes(end)
+return attribs
+
+*********/
+
+//--Test case registration-----------------------------------------------------
+function runTestCase(testcase) {
+    if (testcase() !== true) {
+        $ERROR("Test case returned non-true value!");
+    }
+}

Jint.Tests.Ecma/packages.config

@@ -1,5 +1,5 @@
 <?xml version="1.0" encoding="utf-8"?>
 <packages>
-  <package id="xunit" version="1.9.1" targetFramework="net45" />
-  <package id="xunit.extensions" version="1.9.1" targetFramework="net45" />
+  <package id="xunit" version="1.9.2" targetFramework="net45" />
+  <package id="xunit.extensions" version="1.9.2" targetFramework="net45" />
 </packages>

Jint.Tests/Jint.Tests.csproj

@@ -40,11 +40,13 @@
     <Reference Include="Microsoft.CSharp" />
     <Reference Include="System.Data" />
     <Reference Include="System.Xml" />
-    <Reference Include="xunit">
-      <HintPath>..\packages\xunit.1.9.1\lib\net20\xunit.dll</HintPath>
+    <Reference Include="xunit, Version=1.9.2.1705, Culture=neutral, PublicKeyToken=8d05b1bb7a6fdb6c, processorArchitecture=MSIL">
+      <SpecificVersion>False</SpecificVersion>
+      <HintPath>..\packages\xunit.1.9.2\lib\net20\xunit.dll</HintPath>
     </Reference>
-    <Reference Include="xunit.extensions">
-      <HintPath>..\packages\xunit.extensions.1.9.1\lib\net20\xunit.extensions.dll</HintPath>
+    <Reference Include="xunit.extensions, Version=1.9.2.1705, Culture=neutral, PublicKeyToken=8d05b1bb7a6fdb6c, processorArchitecture=MSIL">
+      <SpecificVersion>False</SpecificVersion>
+      <HintPath>..\packages\xunit.extensions.1.9.2\lib\net20\xunit.extensions.dll</HintPath>
     </Reference>
   </ItemGroup>
   <ItemGroup>

Jint.Tests/packages.config

@@ -1,6 +1,6 @@
 <?xml version="1.0" encoding="utf-8"?>
 <packages>
   <package id="Newtonsoft.Json" version="5.0.6" targetFramework="net45" />
-  <package id="xunit" version="1.9.1" targetFramework="net45" />
-  <package id="xunit.extensions" version="1.9.1" targetFramework="net45" />
+  <package id="xunit" version="1.9.2" targetFramework="net45" />
+  <package id="xunit.extensions" version="1.9.2" targetFramework="net45" />
 </packages>

Jint/Native/Argument/ArgumentsObject.cs

@@ -24,6 +24,7 @@ namespace Jint.Native.Argument
             var len = args.Length;
             var obj = new ArgumentsInstance(engine);
             obj.Prototype = engine.Object.PrototypeObject;
+            obj.Extensible = true;
             obj.FastAddProperty("length", len, true, false, true);
             var map = engine.Object.Construct(Arguments.Empty);
             var mappedNamed = new List<string>();

Jint/Native/Date/DateConstructor.cs

@@ -83,7 +83,7 @@ namespace Jint.Native.Date
             else
             {
                 var y = TypeConverter.ToNumber(arguments[0]);
-                var m = (int) TypeConverter.ToInteger(arguments[0]);
+                var m = (int) TypeConverter.ToInteger(arguments[1]);
                 var date = arguments.Length > 2 ? (int)TypeConverter.ToInteger(arguments[2]) : 1;
                 var hours = arguments.Length > 3 ? (int)TypeConverter.ToInteger(arguments[3]) : 0;
                 var minutes = arguments.Length > 4 ? (int)TypeConverter.ToInteger(arguments[4]) : 0;

Jint/Native/Date/DatePrototype.cs

@@ -1,4 +1,6 @@
-using Jint.Runtime.Interop;
+using System;
+using System.Globalization;
+using Jint.Runtime.Interop;
 
 namespace Jint.Native.Date
 {
@@ -25,48 +27,48 @@ namespace Jint.Native.Date
 
         public void Configure()
         {
-            FastAddProperty("toString", new ClrFunctionInstance<object, object>(Engine, ToString, 0), true, false, true);
-            FastAddProperty("toDateString", new ClrFunctionInstance<object, object>(Engine, ToString, 0), true, false, true);
-            FastAddProperty("toTimeString", new ClrFunctionInstance<object, object>(Engine, ToString, 0), true, false, true);
-            FastAddProperty("toLocaleString", new ClrFunctionInstance<object, object>(Engine, ToString, 0), true, false, true);
-            FastAddProperty("toLocaleDateString", new ClrFunctionInstance<object, object>(Engine, ToString, 0), true, false, true);
-            FastAddProperty("toLocaleTimeString", new ClrFunctionInstance<object, object>(Engine, ToString, 0), true, false, true);
+            FastAddProperty("toString", new ClrFunctionInstance<DateInstance, string>(Engine, ToString, 0), true, false, true);
+            FastAddProperty("toDateString", new ClrFunctionInstance<DateInstance, string>(Engine, ToDateString, 0), true, false, true);
+            FastAddProperty("toTimeString", new ClrFunctionInstance<DateInstance, string>(Engine, ToTimeString, 0), true, false, true);
+            FastAddProperty("toLocaleString", new ClrFunctionInstance<DateInstance, string>(Engine, ToLocaleString, 0), true, false, true);
+            FastAddProperty("toLocaleDateString", new ClrFunctionInstance<DateInstance, string>(Engine, ToLocaleDateString, 0), true, false, true);
+            FastAddProperty("toLocaleTimeString", new ClrFunctionInstance<DateInstance, string>(Engine, ToLocaleTimeString, 0), true, false, true);
             FastAddProperty("valueOf", new ClrFunctionInstance<DateInstance, double>(Engine, ValueOf, 0), true, false, true);
-            FastAddProperty("getTime", new ClrFunctionInstance<object, object>(Engine, ToString, 0), true, false, true);
-            FastAddProperty("getFullYear", new ClrFunctionInstance<object, object>(Engine, ToString, 0), true, false, true);
-            FastAddProperty("getUTCFullYear", new ClrFunctionInstance<object, object>(Engine, ToString, 0), true, false, true);
-            FastAddProperty("getMonth", new ClrFunctionInstance<object, object>(Engine, ToString, 0), true, false, true);
-            FastAddProperty("getUTCMonth", new ClrFunctionInstance<object, object>(Engine, ToString, 0), true, false, true);
-            FastAddProperty("getDate", new ClrFunctionInstance<object, object>(Engine, ToString, 0), true, false, true);
-            FastAddProperty("getUTCDate", new ClrFunctionInstance<object, object>(Engine, ToString, 0), true, false, true);
-            FastAddProperty("getDay", new ClrFunctionInstance<object, object>(Engine, ToString, 0), true, false, true);
-            FastAddProperty("getUTCDay", new ClrFunctionInstance<object, object>(Engine, ToString, 0), true, false, true);
-            FastAddProperty("getHours", new ClrFunctionInstance<object, object>(Engine, ToString, 0), true, false, true);
-            FastAddProperty("getUTCHours", new ClrFunctionInstance<object, object>(Engine, ToString, 0), true, false, true);
-            FastAddProperty("getMinutes", new ClrFunctionInstance<object, object>(Engine, ToString, 0), true, false, true);
-            FastAddProperty("getUTCMinutes", new ClrFunctionInstance<object, object>(Engine, ToString, 0), true, false, true);
-            FastAddProperty("getSeconds", new ClrFunctionInstance<object, object>(Engine, ToString, 0), true, false, true);
-            FastAddProperty("getUTCSeconds", new ClrFunctionInstance<object, object>(Engine, ToString, 0), true, false, true);
-            FastAddProperty("getMilliseconds", new ClrFunctionInstance<object, object>(Engine, ToString, 0), true, false, true);
-            FastAddProperty("getUTCMilliseconds", new ClrFunctionInstance<object, object>(Engine, ToString, 0), true, false, true);
-            FastAddProperty("getTimezoneOffset", new ClrFunctionInstance<object, object>(Engine, ToString, 0), true, false, true);
-            FastAddProperty("setTime", new ClrFunctionInstance<object, object>(Engine, ToString, 0), true, false, true);
-            FastAddProperty("setMilliseconds", new ClrFunctionInstance<object, object>(Engine, ToString, 0), true, false, true);
-            FastAddProperty("setSeconds", new ClrFunctionInstance<object, object>(Engine, ToString, 0), true, false, true);
-            FastAddProperty("setUTCSeconds", new ClrFunctionInstance<object, object>(Engine, ToString, 0), true, false, true);
-            FastAddProperty("setMinutes", new ClrFunctionInstance<object, object>(Engine, ToString, 0), true, false, true);
-            FastAddProperty("setUTCMinutes", new ClrFunctionInstance<object, object>(Engine, ToString, 0), true, false, true);
-            FastAddProperty("setHours", new ClrFunctionInstance<object, object>(Engine, ToString, 0), true, false, true);
-            FastAddProperty("setUTCHours", new ClrFunctionInstance<object, object>(Engine, ToString, 0), true, false, true);
-            FastAddProperty("setDate", new ClrFunctionInstance<object, object>(Engine, ToString, 0), true, false, true);
-            FastAddProperty("setUTCDate", new ClrFunctionInstance<object, object>(Engine, ToString, 0), true, false, true);
-            FastAddProperty("setMonth", new ClrFunctionInstance<object, object>(Engine, ToString, 0), true, false, true);
-            FastAddProperty("setUTCMonth", new ClrFunctionInstance<object, object>(Engine, ToString, 0), true, false, true);
-            FastAddProperty("setFullYear", new ClrFunctionInstance<object, object>(Engine, ToString, 0), true, false, true);
-            FastAddProperty("setUTCFullYear", new ClrFunctionInstance<object, object>(Engine, ToString, 0), true, false, true);
-            FastAddProperty("toUTCString", new ClrFunctionInstance<object, object>(Engine, ToString, 0), true, false, true);
-            FastAddProperty("toISOString", new ClrFunctionInstance<object, object>(Engine, ToString, 0), true, false, true);
-            FastAddProperty("toJSON", new ClrFunctionInstance<object, object>(Engine, ToString, 0), true, false, true);
+            FastAddProperty("getTime", new ClrFunctionInstance<DateInstance, double>(Engine, GetTime, 0), true, false, true);
+            FastAddProperty("getFullYear", new ClrFunctionInstance<DateInstance, double>(Engine, GetFullYear, 0), true, false, true);
+            FastAddProperty("getUTCFullYear", new ClrFunctionInstance<DateInstance, double>(Engine, GetUTCFullYear, 0), true, false, true);
+            FastAddProperty("getMonth", new ClrFunctionInstance<DateInstance, double>(Engine, GetMonth, 0), true, false, true);
+            FastAddProperty("getUTCMonth", new ClrFunctionInstance<DateInstance, double>(Engine, GetUTCMonth, 0), true, false, true);
+            FastAddProperty("getDate", new ClrFunctionInstance<DateInstance, double>(Engine, GetDate, 0), true, false, true);
+            FastAddProperty("getUTCDate", new ClrFunctionInstance<DateInstance, double>(Engine, GetUTCDate, 0), true, false, true);
+            FastAddProperty("getDay", new ClrFunctionInstance<DateInstance, double>(Engine, GetDay, 0), true, false, true);
+            FastAddProperty("getUTCDay", new ClrFunctionInstance<DateInstance, double>(Engine, GetUTCDay, 0), true, false, true);
+            FastAddProperty("getHours", new ClrFunctionInstance<DateInstance, double>(Engine, GetHours, 0), true, false, true);
+            FastAddProperty("getUTCHours", new ClrFunctionInstance<DateInstance, double>(Engine, GetUTCHours, 0), true, false, true);
+            FastAddProperty("getMinutes", new ClrFunctionInstance<DateInstance, double>(Engine, GetMinutes, 0), true, false, true);
+            FastAddProperty("getUTCMinutes", new ClrFunctionInstance<DateInstance, double>(Engine, GetUTCMinutes, 0), true, false, true);
+            FastAddProperty("getSeconds", new ClrFunctionInstance<DateInstance, double>(Engine, GetSeconds, 0), true, false, true);
+            FastAddProperty("getUTCSeconds", new ClrFunctionInstance<DateInstance, double>(Engine, GetUTCSeconds, 0), true, false, true);
+            FastAddProperty("getMilliseconds", new ClrFunctionInstance<DateInstance, double>(Engine, GetMilliseconds, 0), true, false, true);
+            FastAddProperty("getUTCMilliseconds", new ClrFunctionInstance<DateInstance, double>(Engine, GetUTCMilliseconds, 0), true, false, true);
+            FastAddProperty("getTimezoneOffset", new ClrFunctionInstance<DateInstance, double>(Engine, GetTimezoneOffset, 0), true, false, true);
+            FastAddProperty("setTime", new ClrFunctionInstance<DateInstance, double>(Engine, SetTime, 0), true, false, true);
+            FastAddProperty("setMilliseconds", new ClrFunctionInstance<DateInstance, double>(Engine, SetMilliseconds, 0), true, false, true);
+            FastAddProperty("setSeconds", new ClrFunctionInstance<DateInstance, double>(Engine, SetSeconds, 0), true, false, true);
+            FastAddProperty("setUTCSeconds", new ClrFunctionInstance<DateInstance, double>(Engine, SetUTCSeconds, 0), true, false, true);
+            FastAddProperty("setMinutes", new ClrFunctionInstance<DateInstance, double>(Engine, SetMinutes, 0), true, false, true);
+            FastAddProperty("setUTCMinutes", new ClrFunctionInstance<DateInstance, double>(Engine, SetUTCMinutes, 0), true, false, true);
+            FastAddProperty("setHours", new ClrFunctionInstance<DateInstance, double>(Engine, SetHours, 0), true, false, true);
+            FastAddProperty("setUTCHours", new ClrFunctionInstance<DateInstance, double>(Engine, SetUTCHours, 0), true, false, true);
+            FastAddProperty("setDate", new ClrFunctionInstance<DateInstance, double>(Engine, SetDate, 0), true, false, true);
+            FastAddProperty("setUTCDate", new ClrFunctionInstance<DateInstance, double>(Engine, SetUTCDate, 0), true, false, true);
+            FastAddProperty("setMonth", new ClrFunctionInstance<DateInstance, double>(Engine, SetMonth, 0), true, false, true);
+            FastAddProperty("setUTCMonth", new ClrFunctionInstance<DateInstance, double>(Engine, SetUTCMonth, 0), true, false, true);
+            FastAddProperty("setFullYear", new ClrFunctionInstance<DateInstance, double>(Engine, SetFullYear, 0), true, false, true);
+            FastAddProperty("setUTCFullYear", new ClrFunctionInstance<DateInstance, double>(Engine, SetUTCFullYear, 0), true, false, true);
+            FastAddProperty("toUTCString", new ClrFunctionInstance<DateInstance, string>(Engine, ToUTCString, 0), true, false, true);
+            FastAddProperty("toISOString", new ClrFunctionInstance<DateInstance, string>(Engine, ToISOString, 0), true, false, true);
+            FastAddProperty("toJSON", new ClrFunctionInstance<DateInstance, string>(Engine, ToJSON, 0), true, false, true);
         }
 
         private double ValueOf(DateInstance thisObj, object[] arguments)
@@ -74,9 +76,288 @@ namespace Jint.Native.Date
             return thisObj.PrimitiveValue;
         }
 
-        private object ToString(object arg1, object[] arg2)
+        private string ToString(DateInstance thisObj, object[] arg2)
         {
-            throw new System.NotImplementedException();
+            return thisObj.ToDateTime().ToString("F", CultureInfo.InvariantCulture);
         }
+
+        private string ToDateString(DateInstance thisObj, object[] arguments)
+        {
+            return thisObj.ToDateTime().ToString("D", CultureInfo.InvariantCulture);
+        }
+
+        private string ToTimeString(DateInstance thisObj, object[] arguments)
+        {
+            return thisObj.ToDateTime().ToString("T", CultureInfo.InvariantCulture);
+        }
+
+        private string ToLocaleString(DateInstance thisObj, object[] arguments)
+        {
+            return thisObj.ToDateTime().ToString("F");
+        }
+
+        private string ToLocaleDateString(DateInstance thisObj, object[] arguments)
+        {
+            return thisObj.ToDateTime().ToString("D");
+        }
+
+        private string ToLocaleTimeString(DateInstance thisObj, object[] arguments)
+        {
+            return thisObj.ToDateTime().ToString("T");
+        }
+
+        private double GetTime(DateInstance thisObj, object[] arguments)
+        {
+            if (double.IsNaN(thisObj.PrimitiveValue))
+            {
+                return double.NaN;
+            }
+
+            return thisObj.PrimitiveValue;
+        }
+
+        private double GetFullYear(DateInstance thisObj, object[] arguments)
+        {
+            if (double.IsNaN(thisObj.PrimitiveValue))
+            {
+                return double.NaN;
+            }
+
+            return thisObj.ToDateTime().Year;
+        }
+
+        private double GetUTCFullYear(DateInstance thisObj, object[] arguments)
+        {
+            if (double.IsNaN(thisObj.PrimitiveValue))
+            {
+                return double.NaN;
+            }
+
+            return thisObj.ToDateTime().ToUniversalTime().Year;
+        }
+
+        private double GetMonth(DateInstance thisObj, object[] arguments)
+        {
+            if (double.IsNaN(thisObj.PrimitiveValue))
+            {
+                return double.NaN;
+            }
+
+            return thisObj.ToDateTime().Month - 1;
+        }
+
+        private double GetUTCMonth(DateInstance thisObj, object[] arguments)
+        {
+            if (double.IsNaN(thisObj.PrimitiveValue))
+            {
+                return double.NaN;
+            }
+
+            return thisObj.ToDateTime().ToUniversalTime().Month;
+        }
+
+        private double GetDate(DateInstance thisObj, object[] arguments)
+        {
+            if (double.IsNaN(thisObj.PrimitiveValue))
+            {
+                return double.NaN;
+            }
+
+            return thisObj.ToDateTime().Day;
+        }
+
+        private double GetUTCDate(DateInstance thisObj, object[] arguments)
+        {
+            if (double.IsNaN(thisObj.PrimitiveValue))
+            {
+                return double.NaN;
+            }
+
+            return thisObj.ToDateTime().ToUniversalTime().Day;
+        }
+
+        private double GetDay(DateInstance thisObj, object[] arguments)
+        {
+            if (double.IsNaN(thisObj.PrimitiveValue))
+            {
+                return double.NaN;
+            }
+
+            return (int)thisObj.ToDateTime().DayOfWeek;
+        }
+
+        private double GetUTCDay(DateInstance thisObj, object[] arguments)
+        {
+            if (double.IsNaN(thisObj.PrimitiveValue))
+            {
+                return double.NaN;
+            }
+
+            return (int)thisObj.ToDateTime().ToUniversalTime().DayOfWeek;
+        }
+
+        private double GetHours(DateInstance thisObj, object[] arguments)
+        {
+            if (double.IsNaN(thisObj.PrimitiveValue))
+            {
+                return double.NaN;
+            }
+
+            return thisObj.ToDateTime().Hour;
+        }
+
+        private double GetUTCHours(DateInstance thisObj, object[] arguments)
+        {
+            if (double.IsNaN(thisObj.PrimitiveValue))
+            {
+                return double.NaN;
+            }
+
+            return thisObj.ToDateTime().ToUniversalTime().Hour;
+        }
+
+        private double GetMinutes(DateInstance thisObj, object[] arguments)
+        {
+            if (double.IsNaN(thisObj.PrimitiveValue))
+            {
+                return double.NaN;
+            }
+
+            return thisObj.ToDateTime().Minute;
+        }
+
+        private double GetUTCMinutes(DateInstance thisObj, object[] arguments)
+        {
+            if (double.IsNaN(thisObj.PrimitiveValue))
+            {
+                return double.NaN;
+            }
+
+            return thisObj.ToDateTime().ToUniversalTime().Minute;
+        }
+
+        private double GetSeconds(DateInstance thisObj, object[] arguments)
+        {
+            if (double.IsNaN(thisObj.PrimitiveValue))
+            {
+                return double.NaN;
+            }
+
+            return thisObj.ToDateTime().Second;
+        }
+
+        private double GetUTCSeconds(DateInstance thisObj, object[] arguments)
+        {
+            if (double.IsNaN(thisObj.PrimitiveValue))
+            {
+                return double.NaN;
+            }
+
+            return thisObj.ToDateTime().ToUniversalTime().Second;
+        }
+
+        private double GetMilliseconds(DateInstance thisObj, object[] arguments)
+        {
+            if (double.IsNaN(thisObj.PrimitiveValue))
+            {
+                return double.NaN;
+            }
+
+            return thisObj.ToDateTime().Millisecond;
+        }
+
+        private double GetUTCMilliseconds(DateInstance thisObj, object[] arguments)
+        {
+            if (double.IsNaN(thisObj.PrimitiveValue))
+            {
+                return double.NaN;
+            }
+
+            return thisObj.ToDateTime().ToUniversalTime().Second;
+        }
+
+        private double GetTimezoneOffset(DateInstance thisObj, object[] arguments)
+        {
+            if (double.IsNaN(thisObj.PrimitiveValue))
+            {
+                return double.NaN;
+            }
+
+            return TimeZoneInfo.Local.GetUtcOffset(thisObj.ToDateTime()).Hours;
+        }
+
+        private double SetTime(DateInstance thisObj, object[] arguments)
+        {
+            throw new NotImplementedException();
+        }
+
+        private double SetMilliseconds(DateInstance thisObj, object[] arguments)
+        {
+            throw new NotImplementedException();
+        }
+
+        private double SetSeconds(DateInstance thisObj, object[] arguments)
+        {
+            throw new NotImplementedException();
+        }
+
+        private double SetUTCSeconds(DateInstance thisObj, object[] arguments)
+        {
+            throw new NotImplementedException();
+        }
+
+        private double SetMinutes(DateInstance thisObj, object[] arguments)
+        {
+            throw new NotImplementedException();
+        }
+
+        private double SetUTCMinutes(DateInstance thisObj, object[] arguments)
+        {
+            throw new NotImplementedException();
+        }
+
+        private double SetHours(DateInstance thisObj, object[] arguments)
+        {
+            throw new NotImplementedException();
+        }
+
+        private double SetUTCHours(DateInstance thisObj, object[] arguments)
+        {
+            throw new NotImplementedException();
+        }
+
+        private double SetDate(DateInstance thisObj, object[] arguments)
+        {
+            throw new NotImplementedException();
+        }
+
+        private double SetUTCDate(DateInstance thisObj, object[] arguments)
+        {
+            throw new NotImplementedException();
+        }
+
+        private double SetMonth(DateInstance thisObj, object[] arguments)
+        {
+            throw new NotImplementedException();
+        }
+
+        private double SetUTCMonth(DateInstance thisObj, object[] arguments)
+        {
+            throw new NotImplementedException();
+        }
+
+        private double SetFullYear(DateInstance thisObj, object[] arguments)
+        {
+            throw new NotImplementedException();
+        }
+
+        private double SetUTCFullYear(DateInstance thisObj, object[] arguments)
+        {
+            throw new NotImplementedException();
+        }
+
+        private string ToUTCString(DateInstance thisObj, object[] arguments) { throw new NotImplementedException(); }
+        private string ToISOString(DateInstance thisObj, object[] arguments) { throw new NotImplementedException(); }
+        private string ToJSON(DateInstance thisObj, object[] arguments) { throw new NotImplementedException(); }
     }
 }

Jint/Native/Function/FunctionConstructor.cs

@@ -22,7 +22,7 @@ namespace Jint.Native.Function
         public static FunctionConstructor CreateFunctionConstructor(Engine engine)
         {
             var obj = new FunctionConstructor(engine);
-
+            obj.Extensible = true;
 
             // The initial value of Function.prototype is the standard built-in Function prototype object
             obj.PrototypeObject = FunctionPrototype.CreatePrototypeObject(engine);

Jint/Native/Object/ObjectConstructor.cs

@@ -20,6 +20,8 @@ namespace Jint.Native.Object
         public static ObjectConstructor CreateObjectConstructor(Engine engine)
         {
             var obj = new ObjectConstructor(engine);
+            obj.Extensible = true;
+
             obj.PrototypeObject = ObjectPrototype.CreatePrototypeObject(engine, obj);
 
             obj.FastAddProperty("length", 1, false, false, false);
@@ -38,12 +40,12 @@ namespace Jint.Native.Object
             FastAddProperty("create", new ClrFunctionInstance<object, object>(Engine, Create), false, false, false);
             FastAddProperty("defineProperty", new ClrFunctionInstance<object, object>(Engine, DefineProperty), false, false, false);
             FastAddProperty("defineProperties", new ClrFunctionInstance<object, object>(Engine, DefineProperties), false, false, false);
-            FastAddProperty("seal", new ClrFunctionInstance<object, object>(Engine, Seal), false, false, false);
-            FastAddProperty("freeze", new ClrFunctionInstance<object, object>(Engine, Freeze), false, false, false);
-            FastAddProperty("preventExtensions", new ClrFunctionInstance<object, object>(Engine, PreventExtensions), false, false, false);
-            FastAddProperty("isSealed", new ClrFunctionInstance<object, object>(Engine, IsSealed), false, false, false);
-            FastAddProperty("isFrozen", new ClrFunctionInstance<object, object>(Engine, IsFrozen), false, false, false);
-            FastAddProperty("isExtensible", new ClrFunctionInstance<object, object>(Engine, IsExtensible), false, false, false);
+            FastAddProperty("seal", new ClrFunctionInstance<object, object>(Engine, Seal, 1), false, false, false);
+            FastAddProperty("freeze", new ClrFunctionInstance<object, object>(Engine, Freeze, 1), false, false, false);
+            FastAddProperty("preventExtensions", new ClrFunctionInstance<object, object>(Engine, PreventExtensions, 1), false, false, false);
+            FastAddProperty("isSealed", new ClrFunctionInstance<object, object>(Engine, IsSealed, 1), false, false, false);
+            FastAddProperty("isFrozen", new ClrFunctionInstance<object, object>(Engine, IsFrozen, 1), false, false, false);
+            FastAddProperty("isExtensible", new ClrFunctionInstance<object, object>(Engine, IsExtensible, 1), false, false, false);
             FastAddProperty("keys", new ClrFunctionInstance<object, object>(Engine, Keys), false, false, false);
         }
 
@@ -311,7 +313,7 @@ namespace Jint.Native.Object
                 }
             }
 
-            if (o.Extensible)
+            if (o.Extensible == false)
             {
                 return true;
             }