[LAB3] 313561001

lab1/main_test.js

@@ -1,23 +1,50 @@
-const test = require('node:test');
 const assert = require('assert');
 const { MyClass, Student } = require('./main');
 
+
 test("Test MyClass's addStudent", () => {
     // TODO
     throw new Error("Test not implemented");
+    const name = 'John'
+    const myClass = new MyClass();
+    assert.strictEqual(myClass.addStudent(name), -1);
+    const student = new Student();
+    student.setName(name[0]);
+    assert.strictEqual(myClass.addStudent(student), 0);
 });
 
 test("Test MyClass's getStudentById", () => {
     // TODO
     throw new Error("Test not implemented");
+    const name = 'John'
+    const myClass = new MyClass();
+    const student = new Student();
+    student.setName(name);
+    const studentId = myClass.addStudent(student);
+    assert.strictEqual(myClass.getStudentById(-1), null);
+    assert.strictEqual(myClass.getStudentById(2), null);
+    assert.strictEqual(myClass.getStudentById(studentId).name, student.name);
 });
 
 test("Test Student's setName", () => {
     // TODO
     throw new Error("Test not implemented");
+    const num = 10;
+    const name = 'John'
+    const student = new Student();
+    student.setName(num);
+    assert.strictEqual(student.name, undefined);
+    student.setName(name);
+    assert.strictEqual(student.name, name);
+
 });
 
 test("Test Student's getName", () => {
     // TODO
     throw new Error("Test not implemented");
+    const name = 'John'
+    const student = new Student();
+    assert.strictEqual(student.getName(), '');
+    student.setName(name);
+    assert.strictEqual(student.getName(), name);
 });

lab2/main_test.js

@@ -3,4 +3,67 @@ const assert = require('assert');
 const { Application, MailSystem } = require('./main');
 
 // TODO: write your tests here
-// Remember to use Stub, Mock, and Spy when necessary
+// Remember to use Stub, Mock, and Spy when necessary
+test('Mocks The mail system', (t) =>{
+
+    const mail = new MailSystem();
+    const name = "John"
+    t.mock.method(mail, 'write');
+    assert.strictEqual(mail.write.mock.callCount(), 0);
+    assert.strictEqual(mail.write(name), 'Congrats, ' + name + '!');
+    assert.strictEqual(mail.write.mock.callCount(), 1);
+
+    const originalRandom = Math.random;
+    Math.random = () => 0.8;
+
+    const context = "Congrats"
+    t.mock.method(mail, 'send');
+    assert.strictEqual(mail.send.mock.callCount(), 0);
+    assert.strictEqual(mail.send(name, context), true);
+    assert.strictEqual(mail.send.mock.callCount(), 1);
+
+    Math.random = originalRandom;
+})
+
+test('Mocks the app system', async (t) => {
+    fs.writeFileSync('name_list.txt', 'A\nB\nC');
+
+    const app = new Application();
+
+    await new Promise(resolve => setTimeout(resolve, 50));
+
+    assert.deepStrictEqual(app.people, ['A', 'B', 'C']);
+    assert.deepStrictEqual(app.selected, []);
+    assert.strictEqual(app.selected.length, 0);
+
+    const originalRandom = Math.random;
+    Math.random = () => 0.1;
+    t.mock.method(app, 'getRandomPerson');
+    assert.strictEqual(app.getRandomPerson.mock.callCount(), 0);
+    assert.strictEqual(app.getRandomPerson(), 'A');
+    assert.strictEqual(app.getRandomPerson.mock.callCount(), 1);
+
+    t.mock.method(app, 'selectNextPerson');
+    assert.strictEqual(app.selectNextPerson.mock.callCount(), 0);
+    assert.strictEqual(app.selectNextPerson(), 'A');
+    assert.strictEqual(app.selectNextPerson.mock.callCount(), 1);
+
+    Math.random = () => 0.4;
+    assert.strictEqual(app.selectNextPerson(), 'B');
+    assert.strictEqual(app.selectNextPerson.mock.callCount(), 2);
+
+    Math.random = () => 0.7;
+    assert.strictEqual(app.selectNextPerson(), 'C');
+    assert.strictEqual(app.selectNextPerson.mock.callCount(), 3);
+
+    assert.strictEqual(app.selectNextPerson(), null);
+    assert.strictEqual(app.selectNextPerson.mock.callCount(), 4);
+
+    t.mock.method(app, 'notifySelected');
+    assert.strictEqual(app.notifySelected.mock.callCount(), 0);
+    app.notifySelected();
+    assert.strictEqual(app.notifySelected.mock.callCount(), 1);
+
+    Math.random = originalRandom;
+    fs.unlinkSync('name_list.txt');
+});

lab3/main_test.js

@@ -3,3 +3,57 @@ const assert = require('assert');
 const { Calculator } = require('./main');
 
 // TODO: write your tests here
+it('Param-Error', () => {
+    const exp_testcases = [
+        {param: NaN, expected: {name: 'Error', message: 'unsupported operand type'}},
+        {param: 9999999, expected: {name: 'Error', message: 'overflow'}}
+    ];
+
+    const Calc = new Calculator();
+
+    for( const ts of exp_testcases){
+        assert.throws(() => {
+            Calc.exp(ts.param);
+        }, ts.expected
+        );
+    };
+
+    const log_testcases = [
+        {param: NaN, expected: {name: 'Error', message: 'unsupported operand type'}},
+        {param: 0, expected: {name: 'Error', message: 'math domain error (1)'}},
+        {param: -1, expected: {name: 'Error', message: 'math domain error (2)'}}
+    ];
+
+    for( const ts of log_testcases){
+        assert.throws(() => {
+            Calc.log(ts.param);
+        }, ts.expected
+        );
+    };
+
+})
+
+it('test', () => {
+    const exp_testcases = [
+        {param: 0, expected: 1},
+        {param: 1, expected: Math.exp(1)},
+        {param: -1, expected: Math.exp(-1)}
+    ];
+
+    const Calc = new Calculator();
+
+    for( const ts of exp_testcases){
+        assert.strictEqual(Calc.exp(ts.param), ts.expected);
+    };
+
+    const log_testcases = [
+        {param: 9, expected: Math.log(9)},
+        {param: 1, expected: Math.log(1)},
+        {param: 100, expected: Math.log(100)}
+    ];
+
+    for( const ts of log_testcases){
+        assert.strictEqual(Calc.log(ts.param), ts.expected);
+    };
+
+})