});
function expandSuccessCB(events) {
- assert_true(false,"expandRecurrence() success callback");
+ assert_unreached("expandRecurrence() success callback");
}
conversionTable = getTypeConversionExceptions("object", false);
});
function expandSuccessCB(events) {
- assert_true(false,"expandRecurrence() success callback");
+ assert_unreached("expandRecurrence() success callback");
}
endDate = {
});
function expandSuccessCB(events) {
- assert_true(false,"expandRecurrence() success callback");
+ assert_unreached("expandRecurrence() success callback");
}
assert_throws({
});
function expandSuccessCB(events) {
- assert_true(false,"expandRecurrence() success callback");
+ assert_unreached("expandRecurrence() success callback");
}
assert_throws({
});
function expandSuccessCB(events) {
- assert_true(false,"expandRecurrence() success callback");
+ assert_unreached("expandRecurrence() success callback");
}
conversionTable = getTypeConversionExceptions("object", false);
});
function expandSuccessCB(events) {
- assert_true(false,"expandRecurrence() success callback");
+ assert_unreached("expandRecurrence() success callback");
}
startDate = {
self = this;
onGetCalendarsSuccessCB = this.step_func(function (response) {
- assert_true(false,"onGetCalendarsSuccessCB");
+ assert_unreached("onGetCalendarsSuccessCB");
});
onGetCalendarsErrorCB = this.step_func(function (error) {
- assert_true(false, "Error: " + error.message);
+ assert_unreached("Error: " + error.message);
});
assert_throws({
var onGetCalendarsSuccessCB, onGetCalendarsErrorCB;
onGetCalendarsSuccessCB = this.step_func(function (response) {
- assert_true(false,"onGetCalendarsSuccessCB");
+ assert_unreached("onGetCalendarsSuccessCB");
});
onGetCalendarsErrorCB = this.step_func(function (error) {
- assert_true(false, "Error: " + error.message);
+ assert_unreached("Error: " + error.message);
});
assert_throws({
});
onGetCalendarsErrorCB = self.step_func(function (response) {
- assert_true(false, "getCalendars error callback");
+ assert_unreached("getCalendars error callback");
});
tizen.calendar.getCalendars("EVENT", onGetCalendarsSuccessCB, onGetCalendarsErrorCB);
//==== SPEC_URL https://developer.tizen.org/help/topic/org.tizen.web.device.apireference/tizen/calendar.html
//==== TEST_CRITERIA CONSTRM CONSTRA
test(function () {
- var exp1, RecurrenceRule_init, RecurrenceRule;
+ var exp1, recurrenceRule_init, recurrenceRule;
exp1 = new tizen.TZDate(2011, 11, 30, 12, 40, 0, 0);
- RecurrenceRule_init = { interval: 2,
+ recurrenceRule_init = { interval: 2,
occurrenceCount: 10,
daysOfTheWeek: ["MO", "TU"],
setPositions: [-1, -2],
exceptions:[exp1] };
- RecurrenceRule = new tizen.CalendarRecurrenceRule("DAILY", RecurrenceRule_init);
- assert_true(RecurrenceRule.frequency in RecurrenceRuleFrequency, "frequency check");
- assert_equals(RecurrenceRule.frequency, "DAILY", "frequency attribute should be set to DAILY");
- assert_equals(RecurrenceRule.interval, 2, "interval");
- assert_equals(RecurrenceRule.untilDate, null, "untilDate check");
- assert_equals(RecurrenceRule.occurrenceCount, 10, "occurenceCount check");
- assert_inEnum(RecurrenceRule.daysOfTheWeek, ByDayValue, "daysOfTheWeek check");
- assert_equalsArrays(RecurrenceRule.setPositions, [-1, -2], "setPositions check");
- assert_true(RecurrenceRule.exceptions[0].equalsTo(exp1), "dates should be equal");
+ recurrenceRule = new tizen.CalendarRecurrenceRule("DAILY", recurrenceRule_init);
+ assert_true(recurrenceRule.frequency in RecurrenceRuleFrequency, "frequency check");
+ assert_equals(recurrenceRule.frequency, "DAILY", "frequency attribute should be set to DAILY");
+ assert_equals(recurrenceRule.interval, 2, "interval");
+ assert_equals(recurrenceRule.untilDate, null, "untilDate check");
+ assert_equals(recurrenceRule.occurrenceCount, 10, "occurenceCount check");
+ assert_isArrayOfDays(recurrenceRule.daysOfTheWeek, "daysOfTheWeek check");
+ assert_array_equals(recurrenceRule.setPositions, [-1, -2], "setPositions check");
+ assert_true(recurrenceRule.exceptions[0].equalsTo(exp1), "dates should be equal");
}, "CalendarRecurrenceRule_constructor");
</script>
"calendarRecurrenceRule.daysOfTheWeek should be updated.");
assert_array_equals(calendarRecurrenceRule.daysOfTheWeek, ["MO", "TU"],
"calendarRecurrenceRule.daysOfTheWeek should be updated.");
- assert_inEnum(calendarRecurrenceRule.daysOfTheWeek, ByDayValue);
+ assert_isArrayOfDays(calendarRecurrenceRule.daysOfTheWeek, "daysOfTheWeek");
calendarRecurrenceRule.daysOfTheWeek = ["SA", "SU"];
assert_equals(calendarRecurrenceRule.daysOfTheWeek.length, 2,
"calendarRecurrenceRule.daysOfTheWeek should be updated.");
assert_array_equals(calendarRecurrenceRule.daysOfTheWeek, ["SA", "SU"],
"calendarRecurrenceRule.daysOfTheWeek should be updated.");
- assert_inEnum(calendarRecurrenceRule.daysOfTheWeek, ByDayValue);
+ assert_isArrayOfDays(calendarRecurrenceRule.daysOfTheWeek, "calendarRecurrenceRule.daysOfTheWeek");
calendarRecurrenceRule.daysOfTheWeek = null;
assert_not_equals(calendarRecurrenceRule.daysOfTheWeek, null,
//==== TEST_CRITERIA
var description = "CalendarRecurrenceRule attribute frequency check",
- exp1, RecurrenceRule_init, RecurrenceRule;
- test(function (){
+ exp1, recurrenceRule_init, recurrenceRule;
+ test(function () {
exp1 = new tizen.TZDate(2011, 11, 30, 12, 40, 0, 0);
- RecurrenceRule_init = {interval: 2,
+ recurrenceRule_init = {interval: 2,
occurrenceCount: 10,
daysOfTheWeek: ["MO","TU"],
setPositions: [-1,-2],
exceptions:[exp1]};
- RecurrenceRule = new tizen.CalendarRecurrenceRule("DAILY",RecurrenceRule_init);
- assert_inEnum(RecurrenceRule.daysOfTheWeek, ByDayValue,"CalendarRecurrenceRule attribute daysOfTheWeek check");
- },description);
+ recurrenceRule = new tizen.CalendarRecurrenceRule("DAILY", recurrenceRule_init);
+ assert_isArrayOfDays(recurrenceRule.daysOfTheWeek, "daysOfTheWeek check");
+ }, description);
</script>
</body>
//==== TEST_CRITERIA
var description = "CalendarRecurrenceRule attribute frequency check",
- exp1, RecurrenceRule_init, RecurrenceRule;
+ exp1, recurrenceRule_init, recurrenceRule;
test(function (){
exp1 = new tizen.TZDate(2011, 11, 30, 12, 40, 0, 0);
- RecurrenceRule_init = {interval: 2,
+ recurrenceRule_init = {interval: 2,
occurrenceCount: 10,
daysOfTheWeek: ["MO","TU"],
setPositions: [-1,-2],
exceptions:[exp1]};
-
- RecurrenceRule = new tizen.CalendarRecurrenceRule("DAILY",RecurrenceRule_init);
- assert_true(RecurrenceRule.exceptions[0].equalsTo(exp1), "dates should be equal");
+
+ recurrenceRule = new tizen.CalendarRecurrenceRule("DAILY", recurrenceRule_init);
+ assert_true(recurrenceRule.exceptions[0].equalsTo(exp1), "dates should be equal");
},description);
</script>
//==== TEST_CRITERIA
var description = "CalendarRecurrenceRule attribute frequency check",
- exp1, RecurrenceRule_init, RecurrenceRule;
+ exp1, recurrenceRule_init, recurrenceRule;
test(function (){
exp1 = new tizen.TZDate(2011, 11, 30, 12, 40, 0, 0);
- RecurrenceRule_init = {interval: 2,
+ recurrenceRule_init = {interval: 2,
occurrenceCount: 10,
daysOfTheWeek: ["MO","TU"],
setPositions: [-1,-2],
exceptions:[exp1]};
- RecurrenceRule = new tizen.CalendarRecurrenceRule("DAILY",RecurrenceRule_init);
- assert_true(RecurrenceRule.frequency in RecurrenceRuleFrequency, "CalendarRecurrenceRule attribute frequency check");
+ recurrenceRule = new tizen.CalendarRecurrenceRule("DAILY", recurrenceRule_init);
+ assert_true(recurrenceRule.frequency in RecurrenceRuleFrequency, "CalendarRecurrenceRule attribute frequency check");
},description);
</script>
//==== TEST_CRITERIA AT
var description = "CalendarRecurrenceRule attribute frequency check",
- exp1, RecurrenceRule_init, RecurrenceRule;
+ exp1, recurrenceRule_init, recurrenceRule;
test(function (){
exp1 = new tizen.TZDate(2011, 11, 30, 12, 40, 0, 0);
- RecurrenceRule_init = {interval: 2,
+ recurrenceRule_init = {interval: 2,
occurrenceCount: 10,
daysOfTheWeek: ["MO","TU"],
setPositions: [-1,-2],
exceptions:[exp1]};
- RecurrenceRule = new tizen.CalendarRecurrenceRule("DAILY",RecurrenceRule_init);
- assert_equals(RecurrenceRule.interval, 2,"CalendarRecurrenceRule attribute interval check");
+ recurrenceRule = new tizen.CalendarRecurrenceRule("DAILY",recurrenceRule_init);
+ assert_equals(recurrenceRule.interval, 2,"CalendarRecurrenceRule attribute interval check");
},description);
</script>
//==== TEST_CRITERIA AT
var description = "CalendarRecurrenceRule attribute frequency check",
- exp1, RecurrenceRule_init, RecurrenceRule;
+ exp1, recurrenceRule_init, recurrenceRule;
test(function (){
exp1 = new tizen.TZDate(2011, 11, 30, 12, 40, 0, 0);
- RecurrenceRule_init = {interval: 2,
+ recurrenceRule_init = {interval: 2,
occurrenceCount: 10,
daysOfTheWeek: ["MO","TU"],
setPositions: [-1,-2],
exceptions:[exp1]};
- RecurrenceRule = new tizen.CalendarRecurrenceRule("DAILY",RecurrenceRule_init);
- assert_equals(RecurrenceRule.occurrenceCount, 10, "CalendarRecurrenceRule attribute occurenceCount check");
+ recurrenceRule = new tizen.CalendarRecurrenceRule("DAILY",recurrenceRule_init);
+ assert_equals(recurrenceRule.occurrenceCount, 10, "CalendarRecurrenceRule attribute occurenceCount check");
},description);
</script>
//==== TEST_CRITERIA
var description = "CalendarRecurrenceRule attribute frequency check",
- exp1, RecurrenceRule_init, RecurrenceRule;
+ exp1, recurrenceRule_init, recurrenceRule;
test(function (){
exp1 = new tizen.TZDate(2011, 11, 30, 12, 40, 0, 0);
- RecurrenceRule_init = {interval: 2,
+ recurrenceRule_init = {interval: 2,
occurrenceCount: 10,
daysOfTheWeek: ["MO","TU"],
setPositions: [-1,-2],
exceptions:[exp1]};
- RecurrenceRule = new tizen.CalendarRecurrenceRule("DAILY",RecurrenceRule_init);
- assert_array_equals(RecurrenceRule.setPositions, [-1, -2],"CalendarRecurrenceRule attribute setPositions check");
+ recurrenceRule = new tizen.CalendarRecurrenceRule("DAILY",recurrenceRule_init);
+ assert_array_equals(recurrenceRule.setPositions, [-1, -2],"CalendarRecurrenceRule attribute setPositions check");
},description);
</script>
//==== TEST_CRITERIA
var description = "CalendarRecurrenceRule attribute frequency check",
- exp1, RecurrenceRule_init, RecurrenceRule;
+ exp1, recurrenceRule_init, recurrenceRule;
test(function (){
exp1 = new tizen.TZDate(2011, 11, 30, 12, 40, 0, 0);
- RecurrenceRule_init = {interval: 2,
+ recurrenceRule_init = {interval: 2,
occurrenceCount: 10,
daysOfTheWeek: ["MO","TU"],
setPositions: [-1,-2],
exceptions:[exp1]};
- RecurrenceRule = new tizen.CalendarRecurrenceRule("DAILY",RecurrenceRule_init);
- assert_equals(RecurrenceRule.untilDate, null, "CalendarRecurrenceRule attribute untilDate check");
+ recurrenceRule = new tizen.CalendarRecurrenceRule("DAILY",recurrenceRule_init);
+ assert_equals(recurrenceRule.untilDate, null, "CalendarRecurrenceRule attribute untilDate check");
},description);
</script>
//==== SPEC Tizen Web API:Social:Calendar:Calendar:addBatch M
//==== SPEC_URL https://developer.tizen.org/help/topic/org.tizen.web.device.apireference/tizen/calendar.html
//==== TEST_CRITERIA MC
-var t = async_test(document.title, {timeout: 10000}), i, conversionTable, exceptionName, successCallback, errorCallback, event, calendar;
+var t = async_test(document.title, {timeout: 10000}), i, conversionTable, exceptionName, successCallback, errorCallback, calendarEvent, calendar;
setup({timeout: 10000});
t.step(function () {
});
calendar = tizen.calendar.getDefaultCalendar("EVENT");
- event = createTestEvent();
+ calendarEvent = createTestEvent();
conversionTable = getTypeConversionExceptions("functionObject", true);
assert_throws({
name: exceptionName
}, function () {
- calendar.addBatch([event], successCallback, errorCallback);
+ calendar.addBatch([calendarEvent], successCallback, errorCallback);
}, exceptionName + " should be thrown - given incorrect errorCallback - " + errorCallback);
}
//==== TEST_CRITERIA MMA MC
test(function () {
- var eventCalendar = tizen.calendar.getDefaultCalendar("EVENT");
+ var eventCalendar = tizen.calendar.getDefaultCalendar("EVENT"), events = [];
assert_throws({
"name": TYPE_MISMATCH_ERR
//==== SPEC Tizen Web API:Social:Calendar:Calendar:addBatch M
//==== SPEC_URL https://developer.tizen.org/help/topic/org.tizen.web.device.apireference/tizen/calendar.html
//==== TEST_CRITERIA MC
-var t = async_test(document.title, {timeout: 10000}), i, conversionTable, exceptionName, successCallback, errorCallback, event, calendar;
+var t = async_test(document.title, {timeout: 10000}), i, conversionTable, exceptionName, successCallback, errorCallback, calendarEvent, calendar;
setup({timeout: 10000});
t.step(function () {
});
calendar = tizen.calendar.getDefaultCalendar("EVENT");
- event = createTestEvent();
+ calendarEvent = createTestEvent();
conversionTable = getTypeConversionExceptions("functionObject", true);
assert_throws({
name: exceptionName
}, function () {
- calendar.addBatch([event], successCallback, errorCallback);
+ calendar.addBatch([calendarEvent], successCallback, errorCallback);
}, exceptionName + " should be thrown - given incorrect successCallback - " + successCallback);
}
});
onFindErrorCB = self.step_func(function () {
- assert_true(false, "Find failed.");
+ assert_unreached("Find failed.");
});
filter = new tizen.AttributeFilter("summary", "CONTAINS", "Tizen");
});
onFindErrorCB = self.step_func(function () {
- assert_true(false, "Find failed.");
+ assert_unreached("Find failed.");
});
filter = new tizen.AttributeFilter("summary", "CONTAINS", "Tizen");
taskSearchSuccessCallback = t.step_func(function (events) {
- assert_equals(returnedValue, undefined, "Incorect returned value from remove()");
+ assert_equals(returnedValue, undefined, "Incorect returned value from remove()");
assert_equals(events.length, 0, "Task should not be found.");
t.done();
});
//==== SPEC Tizen Web API:Social:Calendar:Calendar:remove M
//==== SPEC_URL https://developer.tizen.org/help/topic/org.tizen.web.device.apireference/tizen/calendar.html
//==== TEST_CRITERIA MMINA MAST
-var t = async_test("Calendar_remove_Event", {timeout: 5000}), event,
- eventCalendar, eventSearchSuccessCallback, eventSearchErrorCallback, filter;
+var t = async_test("Calendar_remove_Event", {timeout: 5000}), calendarEvent,
+ calendar, eventSearchSuccessCallback, eventSearchErrorCallback, filter;
t.step(function () {
assert_unreached("find() error callaback invoked: " + error.name + ": " + error.message);
});
- eventCalendar = tizen.calendar.getDefaultCalendar("EVENT");
- event = createTestEvent();
- eventCalendar.add(event);
- filter = new tizen.AttributeFilter("id", "EXACTLY", event.id);
+ calendar = tizen.calendar.getDefaultCalendar("EVENT");
+ calendarEvent = createTestEvent();
+ calendar.add(calendarEvent);
+ filter = new tizen.AttributeFilter("id", "EXACTLY", calendarEvent.id);
- eventCalendar.remove(event.id);
- eventCalendar.find(eventSearchSuccessCallback, eventSearchErrorCallback, filter);
+ calendar.remove(calendarEvent.id);
+ calendar.find(eventSearchSuccessCallback, eventSearchErrorCallback, filter);
});
</script>
//==== TEST_CRITERIA MC MMA
var t = async_test("Calendar_updateBatch_TYpeMismatch");
t.step(function () {
- var onUpdateBatchSuccessCB, taskCalendar = tizen.calendar.getDefaultCalendar("TASK");
+ var onUpdateBatchSuccessCB, taskCalendar = tizen.calendar.getDefaultCalendar("TASK"), tasks = [];
onUpdateBatchSuccessCB = t.step_func(function () {
assert_unreached("updateBatch success callback invoked");
//==== SPEC_URL https://developer.tizen.org/help/topic/org.tizen.web.device.apireference/tizen/calendar.html
//==== TEST_CRITERIA MC
var t = async_test("Calendar_updateBatch_items_TypeMismatch"),
- conversionTable, calendar, i, exceptionName;
+ conversionTable, calendar, i, exceptionName, events;
t.step(function () {
calendar = tizen.calendar.getDefaultCalendar("EVENT");
conversionTable = getTypeConversionExceptions("object", true);
var t = async_test("Calendar_updateBatch_missarg");
t.step(function () {
- var onUpdateBatchSuccessCB,
+ var onUpdateBatchSuccessCB, events = [],
eventCalendar = tizen.calendar.getDefaultCalendar("EVENT");
onUpdateBatchSuccessCB = t.step_func(function () {
//==== SPEC_URL https://developer.tizen.org/help/topic/org.tizen.web.device.apireference/tizen/calendar.html
//==== TEST_CRITERIA MC
var t = async_test("Calendar_updateBatch_successCallback_TypeMismatch"), calendar, successCB,
-exceptionName, i, conversionTable;
+ exceptionName, i, conversionTable, events = [];
t.step(function (){
calendar = tizen.calendar.getDefaultCalendar("EVENT");
conversionTable = getTypeConversionExceptions("object", true);
taskCalendar = tizen.calendar.getDefaultCalendar("TASK");
succCount = 3;
onUpdateBatchErrorCB = t.step_func(function (response) {
- assert_true(false, "Error: " + response.message);
+ assert_unreached("Error: " + response.message);
});
onUpdateBatchSuccessCB = t.step_func(function () {
//==== SPEC_URL https://developer.tizen.org/help/topic/org.tizen.web.device.apireference/tizen/calendar.html
//==== TEST_CRITERIA MC
var t = async_test("Calendar_update_item_TypeMismatch"),
- conversionTable, calendar, i, exceptionName;
+ badEvent, conversionTable, calendar, i, exceptionName;
t.step(function (){
calendar = tizen.calendar.getDefaultCalendar("EVENT");
conversionTable = getTypeConversionExceptions("object", true);
for (i = 0; i < conversionTable.length; i++) {
- event = conversionTable[i][0];
+ badEvent = conversionTable[i][0];
exceptionName = conversionTable[i][1];
assert_throws({name : exceptionName},
function () {
- calendar.update(event);
+ calendar.update(badEvent);
}, exceptionName + " should be thrown - given incorrect items.");
}
cleanup(calendar);
var CalendarTextFormat = { "ICALENDAR_20":0, "VCALENDAR_10":1 };
var AlarmMethod = { "SOUND":0, "DISPLAY":1 };
var RecurrenceRuleFrequency = { "DAILY":0, "WEEKLY":1, "MONTHLY":2, "YEARLY":3 };
-var ByDayValue = { "MO":0, "TU":1, "WE":2, "TH":3, "FR":4, "SA":5, "SU":6 };
var EventAvailability = { "BUSY":0, "FREE":1 };
var AttendeeType = { "INDIVIDUAL":0, "GROUP":1, "RESOURCE":2, "ROOM":3, "UNKNOWN":4 };
var AttendeeStatus = { "PENDING":0, "ACCEPTED":1, "DECLINED":2, "TENTATIVE":3, "DELEGATED":4, "COMPLETED":5, "IN_PROCESS":6 };
var CalendarItemPriority = { "HIGH":0, "MEDIUM":1, "LOW":2 };
var CalendarItemVisibility = { "PUBLIC":0, "PRIVATE":1, "CONFIDENTIAL":2 };
var CalendarItemStatus = { "TENTATIVE":0, "CONFIRMED":1, "CANCELLED":2, "NEEDS_ACTION":3, "IN_PROCESS":4, "COMPLETED":5 };
+var DAYS = ["MO", "TU", "WE", "TH", "FR", "SA", "SU"];
+
var TYPE_MISMATCH_ERR = 'TypeMismatchError';
var INVALID_VALUES_ERR = 'InvalidValuesError';
var NOT_SUPPORTED_ERR = 'NotSupportedError';
var NOT_FOUND_ERR = 'NotFoundError';
-var calendar = null;
-var task = null;
-var events = null;
-var tasks = null;
-var listenerArray = [];
-
-errorCB = function (err) {
- console.log("Error occurs: " + err.name);
- assert_true(false, err.name);
- };
-events_to_ids = function(events) {
+function events_to_ids(events) {
var ids = [];
for (var i=0; i<events.length; i++) {
ids.push(events[i].id);
return ids;
}
-cleanup = function(calendar) {
+function cleanup(calendar) {
var ids = [];
calendar.find(function (found_events) {
var ids = events_to_ids(found_events);
});
}
-assert_equalsArrays = function(array1, array2, msg) {
+function assert_equalsArrays(array1, array2, compare, msg) {
assert_equals(array1.length, array2.length, msg);
for (var i=0; i<array1.length; i++) {
- assert_equals(array1[i], array2[i], msg);
+ compare(array1[i], array2[i], msg);
}
}
-assert_inEnum = function(actual, expected, msg) {
- for (var i=0; i< actual.length; i++) {
- var actual_item = actual[i];
- assert_true(actual_item in expected, msg);
- }
+function assert_isArrayOfDays(value, msg) {
+ assert_true(Array.isArray(value), msg)
+ for (var i = 0; i < value.length; i++) {
+ assert_in_array(value[i], DAYS, msg + " (item " + i + ")");
+ }
}
-assert_equalsSimpleCoordinates = function(c_actual, c_expected, msg) {
+function assert_equalsSimpleCoordinates(c_actual, c_expected, msg) {
if (c_actual == null && c_expected == null) {
- assert_true(true,msg);
return;
}
if (c_actual == null || c_expected == null) {
- assert_true(false, msg + ": one is null but not the other");
- return;
+ assert_equals(c_actual, c_expected, msg);
}
assert_equals(c_actual.latitude, c_expected.latitude, msg +": same latitude");
assert_equals(c_actual.longitude, c_expected.longitude, msg +": same longitude");
}
-assert_equalsDurations = function(d_actual, d_expected, msg) {
+
+function assert_equalsDurations(d_actual, d_expected, msg) {
if (d_actual == null && d_expected == null) {
- assert_true(true, msg);
return;
}
if (d_actual == null || d_expected == null) {
- assert_true(false, msg + ": one is null but not the other");
- return;
+ assert_equals(d_actual, d_expected, msg);
}
assert_equals(d_actual.length, d_expected.length, msg);
assert_equals(d_actual.unit, d_expected.unit, msg);
}
-assert_equalsDates = function(actual_date, expected_date, msg) {
+function assert_equalsDates(actual_date, expected_date, msg) {
if (actual_date == null && expected_date == null) {
- assert_true(true, msg);
return;
}
if (actual_date == null || expected_date == null) {
- assert_true(false, msg + ": one is null but not the other");
- return;
+ assert_true(actual_date, expected_date, msg);
}
assert_equals(actual_date.toString(), expected_date.toString(), msg);
}
-assert_equalsAlarms = function(actual_alarm, expected_alarm, msg) {
+function assert_equalsAlarms(actual_alarm, expected_alarm, msg) {
if (actual_alarm == null && expected_alarm == null) {
- assert_true(true, msg);
return;
}
if (actual_alarm == null || expected_alarm == null) {
- assert_true(false, msg + ": one is null but not the other");
- return;
+ assert_equals(actual_alarm, expected_alarm, msg);
}
assert_equalsDates(actual_alarm.absoluteDate, expected_alarm.absoluteDate, msg);
assert_equalsDurations(actual_alarm.before, expected_alarm.before, msg);
assert_equals(actual_alarm.description, expected_alarm.description, msg);
}
-assert_equalsRRules = function(actual_rrule, expected_rrule, msg) {
+function assert_equalsRRules(actual_rrule, expected_rrule, msg) {
if (actual_rrule == null && expected_rrule == null) {
- assert_true(true, msg);
return;
}
if (actual_rrule == null || expected_rrule == null) {
- assert_true(false, msg + ": one is null but not the other");
- return;
+ assert_equals(actual_rrule, expected_rrule, msg + ": one is null but not the other");
}
assert_equals(actual_rrule.frequency, expected_rrule.frequency, msg);
assert_equalsDates(actual_rrule.untilDate, expected_rrule.untilDate, msg);
assert_equals(actual_rrule.occurrenceCount, expected_rrule.occurrenceCount, msg);
- assert_equalsArrays(actual_rrule.daysOfTheWeek, expected_rrule.daysOfTheWeek, msg);
- assert_equalsArrays(actual_rrule.setPositions, expected_rrule.setPositions, msg);
+ assert_array_equals(actual_rrule.daysOfTheWeek, expected_rrule.daysOfTheWeek, msg);
+ assert_array_equals(actual_rrule.setPositions, expected_rrule.setPositions, msg);
assert_equalsArrays(actual_rrule.exceptions, expected_rrule.exceptions, assert_equalsDates, msg);
}
-
-assert_equalsAttendees = function(actual_att, expected_att, msg) {
+
+function assert_equalsAttendees(actual_att, expected_att, msg) {
if (actual_att == null && expected_att == null) {
- assert_true(true, msg);
return;
}
if (actual_att == null || expected_att == null) {
- assert_true(false, msg + ": one is null but not the other");
- return;
+ assert_equals(actual_att, expected_att, msg);
}
// assert_equals(actual_att.uri, expected_att.uri, msg);
assert_equals(actual_att.name, expected_att.name, msg + " name");
assert_equals(actual_att.group, expected_att.group, msg+ " group");
assert_equals(actual_att.delegatorURI, expected_att.delegatorURI, msg+ " delegatorURI");
assert_equals(actual_att.delegateURI, expected_att.delegateURI, msg+ " delegateURI");
-}
+}
-assert_equalsEvents = function(ev_actual, ev_expected) {
+function assert_equalsEvents(ev_actual, ev_expected) {
assert_equalsDates(ev_actual.startDate, ev_expected.startDate, "same startDate");
assert_equalsDates(ev_actual.endDate, ev_expected.endDate, "same endDate");
assert_equals(ev_actual.summary, ev_expected.summary, "same summary");
assert_equals(ev_actual.description, ev_expected.description, "same description");
- assert_equalsArrays(ev_actual.categories, ev_expected.categories, "same categories");
+ assert_array_equals(ev_actual.categories, ev_expected.categories, "same categories");
assert_equals(ev_actual.isAllDay, ev_expected.isAllDay, "same isAllDay");
assert_equalsDurations(ev_actual.duration, ev_expected.duration, "same duration");
assert_equals(ev_actual.location, ev_expected.location, "same location");
assert_equalsArrays(ev_actual.attendees, ev_expected.attendees, assert_equalsAttendees, "same attendees");
}
-
-
function createTestEvent() {
return new tizen.CalendarEvent({description:'Tizen test event description',
summary:'Tizen test event summary',
location:'Seoul'});
return [task1, task2];
}
-ensureContactRefIsValid = function (contactRef) {
+
+function ensureContactRefIsValid(contactRef) {
var addressBook, testContact, getAddressBook;
try {
projects / test / tct / web / api.git / commitdiff