diff --git a/package.json b/package.json
index 3dc6dc3..4c2b3e0 100644
--- a/package.json
+++ b/package.json
@@ -9,7 +9,6 @@
     "lint:fix": "standard --fix",
     "unit": "tap test/**/*.test.js",
     "test": "npm run unit && npm run test:typescript",
-    "posttest": "rimraf test/fjs-generated*.js",
     "test:typescript": "tsd"
   },
   "repository": {
@@ -25,7 +24,6 @@
   "homepage": "https://github.com/fastify/fast-json-stringify-compiler#readme",
   "devDependencies": {
     "fastify": "^4.0.0",
-    "rimraf": "^3.0.2",
     "sanitize-filename": "^1.6.3",
     "standard": "^17.0.0",
     "tap": "^16.0.0",
diff --git a/test/standalone.test.js b/test/standalone.test.js
index fa26e61..51f773c 100644
--- a/test/standalone.test.js
+++ b/test/standalone.test.js
@@ -8,206 +8,223 @@ const sanitize = require('sanitize-filename')
 
 const { StandaloneSerializer: FjsStandaloneCompiler } = require('../')
 
+const generatedFileNames = []
+
 function generateFileName (routeOpts) {
-  return `/fjs-generated-${sanitize(routeOpts.schema.$id)}-${routeOpts.method}-${routeOpts.httpPart}-${sanitize(routeOpts.url)}.js`
+  const fileName = `/fjs-generated-${sanitize(routeOpts.schema.$id)}-${routeOpts.method}-${routeOpts.httpPart}-${sanitize(routeOpts.url)}.js`
+  generatedFileNames.push(fileName)
+  return fileName
 }
 
-t.test('errors', t => {
-  t.plan(2)
-  t.throws(() => {
-    FjsStandaloneCompiler()
-  }, 'missing restoreFunction')
-  t.throws(() => {
-    FjsStandaloneCompiler({ readMode: false })
-  }, 'missing storeFunction')
-})
-
-t.test('generate standalone code', t => {
+t.test('standalone', t => {
   t.plan(5)
 
-  const base = {
-    $id: 'urn:schema:base',
-    definitions: {
-      hello: { type: 'string' }
-    },
-    type: 'object',
-    properties: {
-      hello: { $ref: '#/definitions/hello' }
+  t.teardown(async () => {
+    for (const fileName of generatedFileNames) {
+      try {
+        await fs.promises.unlink(path.join(__dirname, fileName))
+      } catch (e) {}
     }
-  }
+  })
 
-  const refSchema = {
-    $id: 'urn:schema:ref',
-    type: 'object',
-    properties: {
-      hello: { $ref: 'urn:schema:base#/definitions/hello' }
-    }
-  }
+  t.test('errors', t => {
+    t.plan(2)
+    t.throws(() => {
+      FjsStandaloneCompiler()
+    }, 'missing restoreFunction')
+    t.throws(() => {
+      FjsStandaloneCompiler({ readMode: false })
+    }, 'missing storeFunction')
+  })
 
-  const endpointSchema = {
-    schema: {
-      $id: 'urn:schema:endpoint',
-      $ref: 'urn:schema:ref'
+  t.test('generate standalone code', t => {
+    t.plan(5)
+
+    const base = {
+      $id: 'urn:schema:base',
+      definitions: {
+        hello: { type: 'string' }
+      },
+      type: 'object',
+      properties: {
+        hello: { $ref: '#/definitions/hello' }
+      }
     }
-  }
 
-  const schemaMap = {
-    [base.$id]: base,
-    [refSchema.$id]: refSchema
-  }
-
-  const factory = FjsStandaloneCompiler({
-    readMode: false,
-    storeFunction (routeOpts, schemaSerializerCode) {
-      t.same(routeOpts, endpointSchema)
-      t.type(schemaSerializerCode, 'string')
-      fs.writeFileSync(path.join(__dirname, '/fjs-generated.js'), schemaSerializerCode)
-      t.pass('stored the serializer function')
+    const refSchema = {
+      $id: 'urn:schema:ref',
+      type: 'object',
+      properties: {
+        hello: { $ref: 'urn:schema:base#/definitions/hello' }
+      }
     }
-  })
 
-  const compiler = factory(schemaMap)
-  compiler(endpointSchema)
-  t.pass('compiled the endpoint schema')
-
-  t.test('usage standalone code', t => {
-    t.plan(3)
-    const standaloneSerializer = require('./fjs-generated')
-    t.ok(standaloneSerializer)
+    const endpointSchema = {
+      schema: {
+        $id: 'urn:schema:endpoint',
+        $ref: 'urn:schema:ref'
+      }
+    }
 
-    const valid = standaloneSerializer({ hello: 'world' })
-    t.same(valid, JSON.stringify({ hello: 'world' }))
+    const schemaMap = {
+      [base.$id]: base,
+      [refSchema.$id]: refSchema
+    }
 
-    const invalid = standaloneSerializer({ hello: [] })
-    t.same(invalid, '{"hello":""}')
-  })
-})
+    const factory = FjsStandaloneCompiler({
+      readMode: false,
+      storeFunction (routeOpts, schemaSerializerCode) {
+        t.same(routeOpts, endpointSchema)
+        t.type(schemaSerializerCode, 'string')
+        fs.writeFileSync(path.join(__dirname, '/fjs-generated.js'), schemaSerializerCode)
+        generatedFileNames.push('/fjs-generated.js')
+        t.pass('stored the serializer function')
+      }
+    })
 
-t.test('fastify integration - writeMode', async t => {
-  t.plan(4)
-
-  const factory = FjsStandaloneCompiler({
-    readMode: false,
-    storeFunction (routeOpts, schemaSerializationCode) {
-      const fileName = generateFileName(routeOpts)
-      t.ok(routeOpts)
-      fs.writeFileSync(path.join(__dirname, fileName), schemaSerializationCode)
-      t.pass(`stored the serializer function ${fileName}`)
-    },
-    restoreFunction () {
-      t.fail('write mode ON')
-    }
-  })
+    const compiler = factory(schemaMap)
+    compiler(endpointSchema)
+    t.pass('compiled the endpoint schema')
 
-  const app = buildApp(factory)
-  await app.ready()
-})
+    t.test('usage standalone code', t => {
+      t.plan(3)
+      const standaloneSerializer = require('./fjs-generated')
+      t.ok(standaloneSerializer)
 
-t.test('fastify integration - writeMode forces standalone', async t => {
-  t.plan(4)
-
-  const factory = FjsStandaloneCompiler({
-    readMode: false,
-    storeFunction (routeOpts, schemaSerializationCode) {
-      const fileName = generateFileName(routeOpts)
-      t.ok(routeOpts)
-      fs.writeFileSync(path.join(__dirname, fileName), schemaSerializationCode)
-      t.pass(`stored the serializer function ${fileName}`)
-    },
-    restoreFunction () {
-      t.fail('write mode ON')
-    }
-  })
+      const valid = standaloneSerializer({ hello: 'world' })
+      t.same(valid, JSON.stringify({ hello: 'world' }))
 
-  const app = buildApp(factory, {
-    mode: 'not-standalone',
-    rounding: 'ceil'
+      const invalid = standaloneSerializer({ hello: [] })
+      t.same(invalid, '{"hello":""}')
+    })
   })
 
-  await app.ready()
-})
+  t.test('fastify integration - writeMode', async t => {
+    t.plan(4)
+
+    const factory = FjsStandaloneCompiler({
+      readMode: false,
+      storeFunction (routeOpts, schemaSerializationCode) {
+        const fileName = generateFileName(routeOpts)
+        t.ok(routeOpts)
+        fs.writeFileSync(path.join(__dirname, fileName), schemaSerializationCode)
+        t.pass(`stored the serializer function ${fileName}`)
+      },
+      restoreFunction () {
+        t.fail('write mode ON')
+      }
+    })
 
-t.test('fastify integration - readMode', async t => {
-  t.plan(6)
-
-  const factory = FjsStandaloneCompiler({
-    readMode: true,
-    storeFunction () {
-      t.fail('read mode ON')
-    },
-    restoreFunction (routeOpts) {
-      const fileName = generateFileName(routeOpts)
-      t.pass(`restore the serializer function ${fileName}}`)
-      return require(path.join(__dirname, fileName))
-    }
+    const app = buildApp(factory)
+    await app.ready()
   })
 
-  const app = buildApp(factory)
-  await app.ready()
+  t.test('fastify integration - writeMode forces standalone', async t => {
+    t.plan(4)
+
+    const factory = FjsStandaloneCompiler({
+      readMode: false,
+      storeFunction (routeOpts, schemaSerializationCode) {
+        const fileName = generateFileName(routeOpts)
+        t.ok(routeOpts)
+        fs.writeFileSync(path.join(__dirname, fileName), schemaSerializationCode)
+        t.pass(`stored the serializer function ${fileName}`)
+      },
+      restoreFunction () {
+        t.fail('write mode ON')
+      }
+    })
 
-  let res = await app.inject({
-    url: '/foo',
-    method: 'POST'
-  })
-  t.equal(res.statusCode, 200)
-  t.equal(res.payload, JSON.stringify({ hello: 'world' }))
+    const app = buildApp(factory, {
+      mode: 'not-standalone',
+      rounding: 'ceil'
+    })
 
-  res = await app.inject({
-    url: '/bar?lang=it',
-    method: 'GET'
+    await app.ready()
   })
-  t.equal(res.statusCode, 200)
-  t.equal(res.payload, JSON.stringify({ lang: 'en' }))
-})
 
-function buildApp (factory, serializerOpts) {
-  const app = fastify({
-    exposeHeadRoutes: false,
-    jsonShorthand: false,
-    schemaController: {
-      compilersFactory: {
-        buildSerializer: factory
+  t.test('fastify integration - readMode', async t => {
+    t.plan(6)
+
+    const factory = FjsStandaloneCompiler({
+      readMode: true,
+      storeFunction () {
+        t.fail('read mode ON')
+      },
+      restoreFunction (routeOpts) {
+        const fileName = generateFileName(routeOpts)
+        t.pass(`restore the serializer function ${fileName}}`)
+        return require(path.join(__dirname, fileName))
       }
-    },
-    serializerOpts
+    })
+
+    const app = buildApp(factory)
+    await app.ready()
+
+    let res = await app.inject({
+      url: '/foo',
+      method: 'POST'
+    })
+    t.equal(res.statusCode, 200)
+    t.equal(res.payload, JSON.stringify({ hello: 'world' }))
+
+    res = await app.inject({
+      url: '/bar?lang=it',
+      method: 'GET'
+    })
+    t.equal(res.statusCode, 200)
+    t.equal(res.payload, JSON.stringify({ lang: 'en' }))
   })
 
-  app.addSchema({
-    $id: 'urn:schema:foo',
-    type: 'object',
-    properties: {
-      name: { type: 'string' },
-      id: { type: 'integer' }
-    }
-  })
-
-  app.post('/foo', {
-    schema: {
-      response: {
-        200: {
-          $id: 'urn:schema:response',
-          type: 'object',
-          properties: {
-            hello: { $ref: 'urn:schema:foo#/properties/name' }
+  function buildApp (factory, serializerOpts) {
+    const app = fastify({
+      exposeHeadRoutes: false,
+      jsonShorthand: false,
+      schemaController: {
+        compilersFactory: {
+          buildSerializer: factory
+        }
+      },
+      serializerOpts
+    })
+
+    app.addSchema({
+      $id: 'urn:schema:foo',
+      type: 'object',
+      properties: {
+        name: { type: 'string' },
+        id: { type: 'integer' }
+      }
+    })
+
+    app.post('/foo', {
+      schema: {
+        response: {
+          200: {
+            $id: 'urn:schema:response',
+            type: 'object',
+            properties: {
+              hello: { $ref: 'urn:schema:foo#/properties/name' }
+            }
           }
         }
       }
-    }
-  }, () => { return { hello: 'world' } })
-
-  app.get('/bar', {
-    schema: {
-      response: {
-        200: {
-          $id: 'urn:schema:response:bar',
-          type: 'object',
-          properties: {
-            lang: { type: 'string', enum: ['it', 'en'] }
+    }, () => { return { hello: 'world' } })
+
+    app.get('/bar', {
+      schema: {
+        response: {
+          200: {
+            $id: 'urn:schema:response:bar',
+            type: 'object',
+            properties: {
+              lang: { type: 'string', enum: ['it', 'en'] }
+            }
           }
         }
       }
-    }
-  }, () => { return { lang: 'en' } })
+    }, () => { return { lang: 'en' } })
 
-  return app
-}
+    return app
+  }
+})