describe('testingModuleMethod', () => {
        describe('when errors', () => {
            const consoleSpy = jest.spyOn(console, 'error');
    
            HelperClass.mockImplementation(() => ({
                    helperClassMethod: jest.fn(() => { throw new Error('Error') })
                }));

            await expect(testingModuleMethod(data)).rejects.toThrow('Error');
            expect(consoleSpy).toHaveBeenCalled();

            consoleSpy.mockRestore();
        });
    });

        HelperClass.mockImplementation(
            jest.fn().mockImplementation(() => ({
                helperClassMethod: jest.fn()
            }))
        );

const { testingModuleMethod } = require('../testingModule');
const HelperClass = require('./helperClass');

jest.mock('../helperClass', () =>
    jest.fn().mockImplementation(() => ({
        helperClassMethod: jest.fn()
    }))
);

describe('testingModule.js', () => {

    beforeEach(() => {
        HelperClass.mockImplementation(
            jest.fn().mockImplementation(() => ({
                helperClassMethod: jest.fn()
            }))
        );
    });

    describe('testingModuleMethod', () => {
        describe('when errors', () => {
            const consoleSpy = jest.spyOn(console, 'error');
    
            HelperClass.mockImplementation(() => ({
                    helperClassMethod: jest.fn(() => { throw new Error('Error') })
                }));

            await expect(testingModuleMethod(data)).rejects.toThrow('Error');
            expect(consoleSpy).toHaveBeenCalled();

            consoleSpy.mockRestore();
        });
    });
});

   @Test
    public void test_method(){
        ActualClass spyActualClass = Mockito.spy(actualClassMock);

        doNothing().when(spyActualClass).validate(Mockito.any(), Mockito.any());
        spyActualClass.method();
    }

actualClassMock.method();

spyActualClass.method();

it('throws an error if user signs up with email that is in use', async () => {
    try {
        await service();
        expect(...);
    } catch (err) {
    }
});

it('throws an error if user signs up with email that is in use', (done) => {
    ...
    service()
     .then( ...) {}
     .catch( ...) {}
    }
    done();
});

       - task: reportgenerator@4
         displayName: 'Merge code coverage reports'
         inputs:
           reports: '$(Agent.TempDirectory)/**/coverage.cobertura.xml'
           targetdir: '$(Pipeline.Workspace)/coverlet'
           reporttypes: 'Cobertura'
           verbosity: 'Verbose'
     
       - task: PublishCodeCoverageResults@1
         displayName: 'Publish code coverage results'
         inputs:
           codeCoverageTool: Cobertura
           summaryFileLocation: '$(Pipeline.Workspace)/coverlet/Cobertura.xml'

var entryPoint = typeof(Program).Assembly.EntryPoint!;
entryPoint.Invoke(null, new object[] { Array.Empty() }); 

// ...
// your top-level statements

public partial class Program { }

std::string getInstance(base **obj) {
    try {
        if (!obj)
            throw std::invalid_argument("");

        *obj = new base();
        return "SUCCESS";
    }
    catch (const std::bad_alloc& e) {
        return "NO_MEMORY";
    }
    catch (...) {
        return "UNDEFINED_ERROR";
    }
}

#ifdef UNIT_TESTING
// simulate there is no memory
base::base() { throw std::bad_alloc; }
#else
base::base() { }
#endif

class TestClassForMyDjangoApp(TestCase):
    def test_for_my_app(self):
        factory = RequestFactory()
        my_header = {"HTTP_CUSTOM_KEY": "VALUE"}
        request = factory.get("/some/url/", **my_header)
        print(request.headers) # {'Custom-Key': 'VALUE'}

await instance.server.mount();

await instance.app
       .use(instance.router.routes()) // populate KOA routes
       .use(instance.router.allowedMethods()); // populate KOA methods
instance.server = http.createServer(instance.app.callback());

 strapi.server.httpServer

 strapi.server

 yarn add --dev jest supertest sqlite3

 npm install --save-dev jest supertest sqlite3

"scripts": {
   // ...strapi scripts
  "test": "jest --forceExit --detectOpenHandles", //add
  "watch": "yarn test --watch", // optional
}

module.exports = {
    verbose: true,
    testPathIgnorePatterns: [
        "/node_modules/",
        ".tmp",
        ".cache"
    ],
    modulePaths: [
        "/node_modules/",
    ],
    testEnvironment: "node",
};

{
    "connection": {
        "client": "sqlite",
        "connection": {
            "filename": ".tmp/test.db"
        },
        "useNullAsDefault": true,
        "pool": {
            "min": 0,
            "max": 1
        }
    }
}

const Strapi = require("@strapi/strapi");
const fs = require("fs");

let instance;

async function setupStrapi() {
  if (!instance) {
    await Strapi().load();
    instance = strapi;
    await instance.server.mount();
  }
  return instance;
}

async function cleanupStrapi() {
  const dbSettings = strapi.config.get("database.connection");
  const tmpDbFile = dbSettings.connection.filename

  //close server to release the db-file
  await strapi.server.httpServer.close();

  //delete test database after all tests
  if (dbSettings && tmpDbFile) {
    if (fs.existsSync(tmpDbFile)) {
      fs.unlinkSync(tmpDbFile);
    }
  }
  // close the connection to the database
  await strapi.db.connection.destroy();
}

module.exports = { setupStrapi, cleanupStrapi };

const { setupStrapi, cleanupStrapi } = require("./helpers/strapi");

jest.setTimeout(15000);

beforeAll(async () => {
  await setupStrapi(); 
});

afterAll(async () => {
 await cleanupStrapi();
});

it("strapi is defined", () => {
  expect(strapi).toBeDefined();
});

require('./hello')

const request = require('supertest');

it('should return hello world', async () => {
  await request(strapi.server.httpServer) 
    .get('/api/hello')
    .expect(200) // Expect response http code 200
});