diff --git a/package.json b/package.json
index 176cda6..36f6146 100644
--- a/package.json
+++ b/package.json
@@ -49,6 +49,7 @@
     "@types/fs-extra": "^11.0.4",
     "@types/node": "^24.10.1",
     "@vitest/coverage-v8": "^3.2.4",
+    "combinations": "^1.0.0",
     "concurrently": "^9.2.1",
     "eslint": "^9.39.1",
     "eslint-plugin-n": "^17.23.1",
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index fd06c61..0126c49 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -42,6 +42,9 @@ importers:
       '@vitest/coverage-v8':
         specifier: ^3.2.4
         version: 3.2.4(vitest@3.2.4(@types/node@24.10.1)(jiti@1.21.7))
+      combinations:
+        specifier: ^1.0.0
+        version: 1.0.0
       concurrently:
         specifier: ^9.2.1
         version: 9.2.1
@@ -907,6 +910,9 @@ packages:
   color-name@1.1.4:
     resolution: {integrity: sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==}
 
+  combinations@1.0.0:
+    resolution: {integrity: sha512-aVgTfI/dewHblSn4gF+NZHvS7wtwg9YAPF2EknHMdH+xLsXLLIMpmHkSj64Zxs/R2m9VAAgn3bENjssrn7V4vQ==}
+
   concat-map@0.0.1:
     resolution: {integrity: sha512-/Srv4dswyQNBfohGpz9o6Yb3Gz3SrUDqBH5rTuhGR7ahtlbYKnVxw2bCFMRljaA7EXHaXZ8wsHdodFvbkhKmqg==}
 
@@ -2951,6 +2957,8 @@ snapshots:
 
   color-name@1.1.4: {}
 
+  combinations@1.0.0: {}
+
   concat-map@0.0.1: {}
 
   concurrently@9.2.1:
diff --git a/src/generators/generator.ts b/src/generators/generator.ts
index c8b19b8..a026690 100644
--- a/src/generators/generator.ts
+++ b/src/generators/generator.ts
@@ -3,7 +3,7 @@ import { camelCase, pascalCase, pathCase } from "change-case";
 import { outputFile, pathExists, remove } from "fs-extra/esm";
 import Handlebars from "handlebars";
 import { readFile } from "node:fs/promises";
-import { join, relative } from "node:path";
+import { join, relative, sep } from "node:path";
 import { cwd as processCwd, env } from "node:process";
 import { FileRef } from "./file-ref.js";
 import { resolveConfig, type Config } from "../config.js";
@@ -128,16 +128,20 @@ export function defineGenerator({
       await arg.modifyTemplateFile?.(templateFile, resolvedArgs);
     }
 
+    const targetFileRelativePath = relative(packagePath, targetFile.path())
+      .split(sep)
+      .join("/");
+
     if (args.destroy) {
       if (await targetFile.exists()) {
         await remove(targetFile.path());
 
         logger.success(
-          `Destroyed ${generatorName} \`${entityName}\` at \`${relative(packagePath, targetFile.path())}\`.`,
+          `Destroyed ${generatorName} \`${entityName}\` at \`${targetFileRelativePath}\`.`,
         );
       } else {
         logger.warn(
-          `${generatorName} \`${entityName}\` at \`${relative(packagePath, targetFile.path())}\` does not exist.`,
+          `${generatorName} \`${entityName}\` at \`${targetFileRelativePath}\` does not exist.`,
         );
       }
 
@@ -180,20 +184,11 @@ export function defineGenerator({
         `Generated and copied ${generatorName} \`${entityName}\` to the clipboard.`,
       );
     } else if (resolvedArgs.log) {
-      const border = "─".repeat(
-        Math.max(...templateCompiled.split("\n").map((line) => line.length)),
-      );
-
-      logger.log(border);
-      logger.log(targetFile.path());
-      logger.log(border);
-      logger.log("");
       logger.log(templateCompiled);
-      logger.log(border);
     } else {
       if (await targetFile.exists()) {
         const response = await logger.prompt(
-          `${generatorName} \`${entityName}\` at \`${relative(packagePath, targetFile.path())}\` already exists. Do you want to overwrite this file?`,
+          `${generatorName} \`${entityName}\` at \`${targetFileRelativePath}\` already exists. Do you want to overwrite this file?`,
           { type: "confirm" },
         );
 
@@ -207,7 +202,7 @@ export function defineGenerator({
       await outputFile(targetFile.path(), templateCompiled);
 
       logger.success(
-        `Generated ${generatorName} \`${entityName}\` at \`${relative(packagePath, targetFile.path())}\`.`,
+        `Generated ${generatorName} \`${entityName}\` at \`${targetFileRelativePath}\`.`,
       );
 
       if (config.hooks?.postGenerate) {
diff --git a/src/logger.ts b/src/logger.ts
index ff8c3ef..8f66dac 100644
--- a/src/logger.ts
+++ b/src/logger.ts
@@ -1,3 +1,6 @@
-import { createConsola } from "consola";
+import { createConsola, LogLevels } from "consola";
 
-export const logger = createConsola({ formatOptions: { date: false } });
+export const logger = createConsola({
+  formatOptions: { date: false },
+  level: LogLevels.info,
+});
diff --git a/test/__snapshots__/generators.test.ts.snap b/test/__snapshots__/generators.test.ts.snap
new file mode 100644
index 0000000..b703693
--- /dev/null
+++ b/test/__snapshots__/generators.test.ts.snap
@@ -0,0 +1,9393 @@
+// Vitest Snapshot v1, https://vitest.dev/guide/snapshot.html
+
+exports[`package-type: v1-addon > generator: acceptance-test > args: --log --typescript 1`] = `
+"[log] import { currentURL, visit } from '@ember/test-helpers';
+import { module, test } from 'qunit';
+import { setupApplicationTest } from 'ember-qunit';
+
+module('Acceptance | foo', function (hooks) {
+  setupApplicationTest(hooks);
+
+  test('it visits /foo', async function (assert) {
+    await visit('/foo');
+
+    assert.strictEqual(currentURL(), '/foo');
+  });
+});
+"
+`;
+
+exports[`package-type: v1-addon > generator: acceptance-test > args: --log 1`] = `
+"[log] import { currentURL, visit } from '@ember/test-helpers';
+import { module, test } from 'qunit';
+import { setupApplicationTest } from 'ember-qunit';
+
+module('Acceptance | foo', function (hooks) {
+  setupApplicationTest(hooks);
+
+  test('it visits /foo', async function (assert) {
+    await visit('/foo');
+
+    assert.strictEqual(currentURL(), '/foo');
+  });
+});
+"
+`;
+
+exports[`package-type: v1-addon > generator: acceptance-test > args: --typescript 1`] = `"[success] Generated acceptance-test \`foo\` at \`tests/acceptance/foo-test.ts\`."`;
+
+exports[`package-type: v1-addon > generator: component > args: --classBased --log --namedExport --nested --test --typescript 1`] = `
+"[log] import Component from '@glimmer/component';
+
+export interface FooSignature {
+  Args: {};
+  Blocks: {
+    default: [];
+  };
+  Element: null;
+}
+
+export class Foo extends Component<FooSignature> {
+  <template>
+    {{yield}}
+  </template>
+}
+
+[log] import { render } from '@ember/test-helpers';
+import { module, test } from 'qunit';
+import Foo from 'v1-addon/components/foo';
+import { setupRenderingTest } from 'ember-qunit';
+
+module('Integration | Component | Foo', function (hooks) {
+  setupRenderingTest(hooks);
+
+  test('it renders', async function (assert) {
+    await render(<template><Foo /></template>);
+
+    assert.dom().hasText('');
+
+    await render(
+      <template>
+        <Foo>
+          template block text
+        </Foo>
+      </template>
+    );
+
+    assert.dom().hasText('template block text');
+  });
+});
+"
+`;
+
+exports[`package-type: v1-addon > generator: component > args: --classBased --log --namedExport --nested --test 1`] = `
+"[log] import Component from '@glimmer/component';
+
+export class Foo extends Component {
+  <template>{{yield}}</template>
+}
+
+[log] import { render } from '@ember/test-helpers';
+import { module, test } from 'qunit';
+import Foo from 'v1-addon/components/foo';
+import { setupRenderingTest } from 'ember-qunit';
+
+module('Integration | Component | Foo', function (hooks) {
+  setupRenderingTest(hooks);
+
+  test('it renders', async function (assert) {
+    await render(<template><Foo /></template>);
+
+    assert.dom().hasText('');
+
+    await render(
+      <template>
+        <Foo>
+          template block text
+        </Foo>
+      </template>
+    );
+
+    assert.dom().hasText('template block text');
+  });
+});
+"
+`;
+
+exports[`package-type: v1-addon > generator: component > args: --classBased --log --namedExport --nested --typescript 1`] = `
+"[log] import Component from '@glimmer/component';
+
+export interface FooSignature {
+  Args: {};
+  Blocks: {
+    default: [];
+  };
+  Element: null;
+}
+
+export class Foo extends Component<FooSignature> {
+  <template>
+    {{yield}}
+  </template>
+}
+"
+`;
+
+exports[`package-type: v1-addon > generator: component > args: --classBased --log --namedExport --nested 1`] = `
+"[log] import Component from '@glimmer/component';
+
+export class Foo extends Component {
+  <template>{{yield}}</template>
+}
+"
+`;
+
+exports[`package-type: v1-addon > generator: component > args: --classBased --log --namedExport --test --typescript 1`] = `
+"[log] import Component from '@glimmer/component';
+
+export interface FooSignature {
+  Args: {};
+  Blocks: {
+    default: [];
+  };
+  Element: null;
+}
+
+export class Foo extends Component<FooSignature> {
+  <template>
+    {{yield}}
+  </template>
+}
+
+[log] import { render } from '@ember/test-helpers';
+import { module, test } from 'qunit';
+import Foo from 'v1-addon/components/foo';
+import { setupRenderingTest } from 'ember-qunit';
+
+module('Integration | Component | Foo', function (hooks) {
+  setupRenderingTest(hooks);
+
+  test('it renders', async function (assert) {
+    await render(<template><Foo /></template>);
+
+    assert.dom().hasText('');
+
+    await render(
+      <template>
+        <Foo>
+          template block text
+        </Foo>
+      </template>
+    );
+
+    assert.dom().hasText('template block text');
+  });
+});
+"
+`;
+
+exports[`package-type: v1-addon > generator: component > args: --classBased --log --namedExport --test 1`] = `
+"[log] import Component from '@glimmer/component';
+
+export class Foo extends Component {
+  <template>{{yield}}</template>
+}
+
+[log] import { render } from '@ember/test-helpers';
+import { module, test } from 'qunit';
+import Foo from 'v1-addon/components/foo';
+import { setupRenderingTest } from 'ember-qunit';
+
+module('Integration | Component | Foo', function (hooks) {
+  setupRenderingTest(hooks);
+
+  test('it renders', async function (assert) {
+    await render(<template><Foo /></template>);
+
+    assert.dom().hasText('');
+
+    await render(
+      <template>
+        <Foo>
+          template block text
+        </Foo>
+      </template>
+    );
+
+    assert.dom().hasText('template block text');
+  });
+});
+"
+`;
+
+exports[`package-type: v1-addon > generator: component > args: --classBased --log --namedExport --typescript 1`] = `
+"[log] import Component from '@glimmer/component';
+
+export interface FooSignature {
+  Args: {};
+  Blocks: {
+    default: [];
+  };
+  Element: null;
+}
+
+export class Foo extends Component<FooSignature> {
+  <template>
+    {{yield}}
+  </template>
+}
+"
+`;
+
+exports[`package-type: v1-addon > generator: component > args: --classBased --log --namedExport 1`] = `
+"[log] import Component from '@glimmer/component';
+
+export class Foo extends Component {
+  <template>{{yield}}</template>
+}
+"
+`;
+
+exports[`package-type: v1-addon > generator: component > args: --classBased --log --nested --test --typescript 1`] = `
+"[log] import Component from '@glimmer/component';
+
+export interface FooSignature {
+  Args: {};
+  Blocks: {
+    default: [];
+  };
+  Element: null;
+}
+
+export default class Foo extends Component<FooSignature> {
+  <template>
+    {{yield}}
+  </template>
+}
+
+[log] import { render } from '@ember/test-helpers';
+import { module, test } from 'qunit';
+import Foo from 'v1-addon/components/foo';
+import { setupRenderingTest } from 'ember-qunit';
+
+module('Integration | Component | Foo', function (hooks) {
+  setupRenderingTest(hooks);
+
+  test('it renders', async function (assert) {
+    await render(<template><Foo /></template>);
+
+    assert.dom().hasText('');
+
+    await render(
+      <template>
+        <Foo>
+          template block text
+        </Foo>
+      </template>
+    );
+
+    assert.dom().hasText('template block text');
+  });
+});
+"
+`;
+
+exports[`package-type: v1-addon > generator: component > args: --classBased --log --nested --test 1`] = `
+"[log] import Component from '@glimmer/component';
+
+export default class Foo extends Component {
+  <template>{{yield}}</template>
+}
+
+[log] import { render } from '@ember/test-helpers';
+import { module, test } from 'qunit';
+import Foo from 'v1-addon/components/foo';
+import { setupRenderingTest } from 'ember-qunit';
+
+module('Integration | Component | Foo', function (hooks) {
+  setupRenderingTest(hooks);
+
+  test('it renders', async function (assert) {
+    await render(<template><Foo /></template>);
+
+    assert.dom().hasText('');
+
+    await render(
+      <template>
+        <Foo>
+          template block text
+        </Foo>
+      </template>
+    );
+
+    assert.dom().hasText('template block text');
+  });
+});
+"
+`;
+
+exports[`package-type: v1-addon > generator: component > args: --classBased --log --nested --typescript 1`] = `
+"[log] import Component from '@glimmer/component';
+
+export interface FooSignature {
+  Args: {};
+  Blocks: {
+    default: [];
+  };
+  Element: null;
+}
+
+export default class Foo extends Component<FooSignature> {
+  <template>
+    {{yield}}
+  </template>
+}
+"
+`;
+
+exports[`package-type: v1-addon > generator: component > args: --classBased --log --nested 1`] = `
+"[log] import Component from '@glimmer/component';
+
+export default class Foo extends Component {
+  <template>{{yield}}</template>
+}
+"
+`;
+
+exports[`package-type: v1-addon > generator: component > args: --classBased --log --test --typescript 1`] = `
+"[log] import Component from '@glimmer/component';
+
+export interface FooSignature {
+  Args: {};
+  Blocks: {
+    default: [];
+  };
+  Element: null;
+}
+
+export default class Foo extends Component<FooSignature> {
+  <template>
+    {{yield}}
+  </template>
+}
+
+[log] import { render } from '@ember/test-helpers';
+import { module, test } from 'qunit';
+import Foo from 'v1-addon/components/foo';
+import { setupRenderingTest } from 'ember-qunit';
+
+module('Integration | Component | Foo', function (hooks) {
+  setupRenderingTest(hooks);
+
+  test('it renders', async function (assert) {
+    await render(<template><Foo /></template>);
+
+    assert.dom().hasText('');
+
+    await render(
+      <template>
+        <Foo>
+          template block text
+        </Foo>
+      </template>
+    );
+
+    assert.dom().hasText('template block text');
+  });
+});
+"
+`;
+
+exports[`package-type: v1-addon > generator: component > args: --classBased --log --test 1`] = `
+"[log] import Component from '@glimmer/component';
+
+export default class Foo extends Component {
+  <template>{{yield}}</template>
+}
+
+[log] import { render } from '@ember/test-helpers';
+import { module, test } from 'qunit';
+import Foo from 'v1-addon/components/foo';
+import { setupRenderingTest } from 'ember-qunit';
+
+module('Integration | Component | Foo', function (hooks) {
+  setupRenderingTest(hooks);
+
+  test('it renders', async function (assert) {
+    await render(<template><Foo /></template>);
+
+    assert.dom().hasText('');
+
+    await render(
+      <template>
+        <Foo>
+          template block text
+        </Foo>
+      </template>
+    );
+
+    assert.dom().hasText('template block text');
+  });
+});
+"
+`;
+
+exports[`package-type: v1-addon > generator: component > args: --classBased --log --typescript 1`] = `
+"[log] import Component from '@glimmer/component';
+
+export interface FooSignature {
+  Args: {};
+  Blocks: {
+    default: [];
+  };
+  Element: null;
+}
+
+export default class Foo extends Component<FooSignature> {
+  <template>
+    {{yield}}
+  </template>
+}
+"
+`;
+
+exports[`package-type: v1-addon > generator: component > args: --classBased --log 1`] = `
+"[log] import Component from '@glimmer/component';
+
+export default class Foo extends Component {
+  <template>{{yield}}</template>
+}
+"
+`;
+
+exports[`package-type: v1-addon > generator: component > args: --classBased --namedExport --nested --test --typescript 1`] = `
+"[success] Generated component \`foo\` at \`addon/components/foo/index.gts\`.
+[success] Generated component-test \`foo\` at \`tests/integration/components/foo-test.gts\`."
+`;
+
+exports[`package-type: v1-addon > generator: component > args: --classBased --namedExport --nested --test 1`] = `
+"[success] Generated component \`foo\` at \`addon/components/foo/index.gjs\`.
+[success] Generated component-test \`foo\` at \`tests/integration/components/foo-test.gjs\`."
+`;
+
+exports[`package-type: v1-addon > generator: component > args: --classBased --namedExport --nested --typescript 1`] = `"[success] Generated component \`foo\` at \`addon/components/foo/index.gts\`."`;
+
+exports[`package-type: v1-addon > generator: component > args: --classBased --namedExport --nested 1`] = `"[success] Generated component \`foo\` at \`addon/components/foo/index.gjs\`."`;
+
+exports[`package-type: v1-addon > generator: component > args: --classBased --namedExport --test --typescript 1`] = `
+"[success] Generated component \`foo\` at \`addon/components/foo.gts\`.
+[success] Generated component-test \`foo\` at \`tests/integration/components/foo-test.gts\`."
+`;
+
+exports[`package-type: v1-addon > generator: component > args: --classBased --namedExport --test 1`] = `
+"[success] Generated component \`foo\` at \`addon/components/foo.gjs\`.
+[success] Generated component-test \`foo\` at \`tests/integration/components/foo-test.gjs\`."
+`;
+
+exports[`package-type: v1-addon > generator: component > args: --classBased --namedExport --typescript 1`] = `"[success] Generated component \`foo\` at \`addon/components/foo.gts\`."`;
+
+exports[`package-type: v1-addon > generator: component > args: --classBased --namedExport 1`] = `"[success] Generated component \`foo\` at \`addon/components/foo.gjs\`."`;
+
+exports[`package-type: v1-addon > generator: component > args: --classBased --nested --test --typescript 1`] = `
+"[success] Generated component \`foo\` at \`addon/components/foo/index.gts\`.
+[success] Generated component-test \`foo\` at \`tests/integration/components/foo-test.gts\`."
+`;
+
+exports[`package-type: v1-addon > generator: component > args: --classBased --nested --test 1`] = `
+"[success] Generated component \`foo\` at \`addon/components/foo/index.gjs\`.
+[success] Generated component-test \`foo\` at \`tests/integration/components/foo-test.gjs\`."
+`;
+
+exports[`package-type: v1-addon > generator: component > args: --classBased --nested --typescript 1`] = `"[success] Generated component \`foo\` at \`addon/components/foo/index.gts\`."`;
+
+exports[`package-type: v1-addon > generator: component > args: --classBased --nested 1`] = `"[success] Generated component \`foo\` at \`addon/components/foo/index.gjs\`."`;
+
+exports[`package-type: v1-addon > generator: component > args: --classBased --test --typescript 1`] = `
+"[success] Generated component \`foo\` at \`addon/components/foo.gts\`.
+[success] Generated component-test \`foo\` at \`tests/integration/components/foo-test.gts\`."
+`;
+
+exports[`package-type: v1-addon > generator: component > args: --classBased --test 1`] = `
+"[success] Generated component \`foo\` at \`addon/components/foo.gjs\`.
+[success] Generated component-test \`foo\` at \`tests/integration/components/foo-test.gjs\`."
+`;
+
+exports[`package-type: v1-addon > generator: component > args: --classBased --typescript 1`] = `"[success] Generated component \`foo\` at \`addon/components/foo.gts\`."`;
+
+exports[`package-type: v1-addon > generator: component > args: --classBased 1`] = `"[success] Generated component \`foo\` at \`addon/components/foo.gjs\`."`;
+
+exports[`package-type: v1-addon > generator: component > args: --log --namedExport --nested --test --typescript 1`] = `
+"[log] import type { TOC } from '@ember/component/template-only';
+
+export interface FooSignature {
+  Args: {};
+  Blocks: {
+    default: [];
+  };
+  Element: null;
+}
+
+export const Foo: TOC<FooSignature> = <template>{{yield}}</template>;
+
+[log] import { render } from '@ember/test-helpers';
+import { module, test } from 'qunit';
+import Foo from 'v1-addon/components/foo';
+import { setupRenderingTest } from 'ember-qunit';
+
+module('Integration | Component | Foo', function (hooks) {
+  setupRenderingTest(hooks);
+
+  test('it renders', async function (assert) {
+    await render(<template><Foo /></template>);
+
+    assert.dom().hasText('');
+
+    await render(
+      <template>
+        <Foo>
+          template block text
+        </Foo>
+      </template>
+    );
+
+    assert.dom().hasText('template block text');
+  });
+});
+"
+`;
+
+exports[`package-type: v1-addon > generator: component > args: --log --namedExport --nested --test 1`] = `
+"[log] <template>{{yield}}</template>
+
+[log] import { render } from '@ember/test-helpers';
+import { module, test } from 'qunit';
+import Foo from 'v1-addon/components/foo';
+import { setupRenderingTest } from 'ember-qunit';
+
+module('Integration | Component | Foo', function (hooks) {
+  setupRenderingTest(hooks);
+
+  test('it renders', async function (assert) {
+    await render(<template><Foo /></template>);
+
+    assert.dom().hasText('');
+
+    await render(
+      <template>
+        <Foo>
+          template block text
+        </Foo>
+      </template>
+    );
+
+    assert.dom().hasText('template block text');
+  });
+});
+"
+`;
+
+exports[`package-type: v1-addon > generator: component > args: --log --namedExport --nested --typescript 1`] = `
+"[log] import type { TOC } from '@ember/component/template-only';
+
+export interface FooSignature {
+  Args: {};
+  Blocks: {
+    default: [];
+  };
+  Element: null;
+}
+
+export const Foo: TOC<FooSignature> = <template>{{yield}}</template>;
+"
+`;
+
+exports[`package-type: v1-addon > generator: component > args: --log --namedExport --nested 1`] = `
+"[log] <template>{{yield}}</template>
+"
+`;
+
+exports[`package-type: v1-addon > generator: component > args: --log --namedExport --test --typescript 1`] = `
+"[log] import type { TOC } from '@ember/component/template-only';
+
+export interface FooSignature {
+  Args: {};
+  Blocks: {
+    default: [];
+  };
+  Element: null;
+}
+
+export const Foo: TOC<FooSignature> = <template>{{yield}}</template>;
+
+[log] import { render } from '@ember/test-helpers';
+import { module, test } from 'qunit';
+import Foo from 'v1-addon/components/foo';
+import { setupRenderingTest } from 'ember-qunit';
+
+module('Integration | Component | Foo', function (hooks) {
+  setupRenderingTest(hooks);
+
+  test('it renders', async function (assert) {
+    await render(<template><Foo /></template>);
+
+    assert.dom().hasText('');
+
+    await render(
+      <template>
+        <Foo>
+          template block text
+        </Foo>
+      </template>
+    );
+
+    assert.dom().hasText('template block text');
+  });
+});
+"
+`;
+
+exports[`package-type: v1-addon > generator: component > args: --log --namedExport --test 1`] = `
+"[log] <template>{{yield}}</template>
+
+[log] import { render } from '@ember/test-helpers';
+import { module, test } from 'qunit';
+import Foo from 'v1-addon/components/foo';
+import { setupRenderingTest } from 'ember-qunit';
+
+module('Integration | Component | Foo', function (hooks) {
+  setupRenderingTest(hooks);
+
+  test('it renders', async function (assert) {
+    await render(<template><Foo /></template>);
+
+    assert.dom().hasText('');
+
+    await render(
+      <template>
+        <Foo>
+          template block text
+        </Foo>
+      </template>
+    );
+
+    assert.dom().hasText('template block text');
+  });
+});
+"
+`;
+
+exports[`package-type: v1-addon > generator: component > args: --log --namedExport --typescript 1`] = `
+"[log] import type { TOC } from '@ember/component/template-only';
+
+export interface FooSignature {
+  Args: {};
+  Blocks: {
+    default: [];
+  };
+  Element: null;
+}
+
+export const Foo: TOC<FooSignature> = <template>{{yield}}</template>;
+"
+`;
+
+exports[`package-type: v1-addon > generator: component > args: --log --namedExport 1`] = `
+"[log] <template>{{yield}}</template>
+"
+`;
+
+exports[`package-type: v1-addon > generator: component > args: --log --nested --test --typescript 1`] = `
+"[log] import type { TOC } from '@ember/component/template-only';
+
+export interface FooSignature {
+  Args: {};
+  Blocks: {
+    default: [];
+  };
+  Element: null;
+}
+
+const Foo: TOC<FooSignature> = <template>{{yield}}</template>;
+
+export default Foo;
+
+[log] import { render } from '@ember/test-helpers';
+import { module, test } from 'qunit';
+import Foo from 'v1-addon/components/foo';
+import { setupRenderingTest } from 'ember-qunit';
+
+module('Integration | Component | Foo', function (hooks) {
+  setupRenderingTest(hooks);
+
+  test('it renders', async function (assert) {
+    await render(<template><Foo /></template>);
+
+    assert.dom().hasText('');
+
+    await render(
+      <template>
+        <Foo>
+          template block text
+        </Foo>
+      </template>
+    );
+
+    assert.dom().hasText('template block text');
+  });
+});
+"
+`;
+
+exports[`package-type: v1-addon > generator: component > args: --log --nested --test 1`] = `
+"[log] <template>{{yield}}</template>
+
+[log] import { render } from '@ember/test-helpers';
+import { module, test } from 'qunit';
+import Foo from 'v1-addon/components/foo';
+import { setupRenderingTest } from 'ember-qunit';
+
+module('Integration | Component | Foo', function (hooks) {
+  setupRenderingTest(hooks);
+
+  test('it renders', async function (assert) {
+    await render(<template><Foo /></template>);
+
+    assert.dom().hasText('');
+
+    await render(
+      <template>
+        <Foo>
+          template block text
+        </Foo>
+      </template>
+    );
+
+    assert.dom().hasText('template block text');
+  });
+});
+"
+`;
+
+exports[`package-type: v1-addon > generator: component > args: --log --nested --typescript 1`] = `
+"[log] import type { TOC } from '@ember/component/template-only';
+
+export interface FooSignature {
+  Args: {};
+  Blocks: {
+    default: [];
+  };
+  Element: null;
+}
+
+const Foo: TOC<FooSignature> = <template>{{yield}}</template>;
+
+export default Foo;
+"
+`;
+
+exports[`package-type: v1-addon > generator: component > args: --log --nested 1`] = `
+"[log] <template>{{yield}}</template>
+"
+`;
+
+exports[`package-type: v1-addon > generator: component > args: --log --test --typescript 1`] = `
+"[log] import type { TOC } from '@ember/component/template-only';
+
+export interface FooSignature {
+  Args: {};
+  Blocks: {
+    default: [];
+  };
+  Element: null;
+}
+
+const Foo: TOC<FooSignature> = <template>{{yield}}</template>;
+
+export default Foo;
+
+[log] import { render } from '@ember/test-helpers';
+import { module, test } from 'qunit';
+import Foo from 'v1-addon/components/foo';
+import { setupRenderingTest } from 'ember-qunit';
+
+module('Integration | Component | Foo', function (hooks) {
+  setupRenderingTest(hooks);
+
+  test('it renders', async function (assert) {
+    await render(<template><Foo /></template>);
+
+    assert.dom().hasText('');
+
+    await render(
+      <template>
+        <Foo>
+          template block text
+        </Foo>
+      </template>
+    );
+
+    assert.dom().hasText('template block text');
+  });
+});
+"
+`;
+
+exports[`package-type: v1-addon > generator: component > args: --log --test 1`] = `
+"[log] <template>{{yield}}</template>
+
+[log] import { render } from '@ember/test-helpers';
+import { module, test } from 'qunit';
+import Foo from 'v1-addon/components/foo';
+import { setupRenderingTest } from 'ember-qunit';
+
+module('Integration | Component | Foo', function (hooks) {
+  setupRenderingTest(hooks);
+
+  test('it renders', async function (assert) {
+    await render(<template><Foo /></template>);
+
+    assert.dom().hasText('');
+
+    await render(
+      <template>
+        <Foo>
+          template block text
+        </Foo>
+      </template>
+    );
+
+    assert.dom().hasText('template block text');
+  });
+});
+"
+`;
+
+exports[`package-type: v1-addon > generator: component > args: --log --typescript 1`] = `
+"[log] import type { TOC } from '@ember/component/template-only';
+
+export interface FooSignature {
+  Args: {};
+  Blocks: {
+    default: [];
+  };
+  Element: null;
+}
+
+const Foo: TOC<FooSignature> = <template>{{yield}}</template>;
+
+export default Foo;
+"
+`;
+
+exports[`package-type: v1-addon > generator: component > args: --log 1`] = `
+"[log] <template>{{yield}}</template>
+"
+`;
+
+exports[`package-type: v1-addon > generator: component > args: --namedExport --nested --test --typescript 1`] = `
+"[success] Generated component \`foo\` at \`addon/components/foo/index.gts\`.
+[success] Generated component-test \`foo\` at \`tests/integration/components/foo-test.gts\`."
+`;
+
+exports[`package-type: v1-addon > generator: component > args: --namedExport --nested --test 1`] = `
+"[success] Generated component \`foo\` at \`addon/components/foo/index.gjs\`.
+[success] Generated component-test \`foo\` at \`tests/integration/components/foo-test.gjs\`."
+`;
+
+exports[`package-type: v1-addon > generator: component > args: --namedExport --nested --typescript 1`] = `"[success] Generated component \`foo\` at \`addon/components/foo/index.gts\`."`;
+
+exports[`package-type: v1-addon > generator: component > args: --namedExport --nested 1`] = `"[success] Generated component \`foo\` at \`addon/components/foo/index.gjs\`."`;
+
+exports[`package-type: v1-addon > generator: component > args: --namedExport --test --typescript 1`] = `
+"[success] Generated component \`foo\` at \`addon/components/foo.gts\`.
+[success] Generated component-test \`foo\` at \`tests/integration/components/foo-test.gts\`."
+`;
+
+exports[`package-type: v1-addon > generator: component > args: --namedExport --test 1`] = `
+"[success] Generated component \`foo\` at \`addon/components/foo.gjs\`.
+[success] Generated component-test \`foo\` at \`tests/integration/components/foo-test.gjs\`."
+`;
+
+exports[`package-type: v1-addon > generator: component > args: --namedExport --typescript 1`] = `"[success] Generated component \`foo\` at \`addon/components/foo.gts\`."`;
+
+exports[`package-type: v1-addon > generator: component > args: --namedExport 1`] = `"[success] Generated component \`foo\` at \`addon/components/foo.gjs\`."`;
+
+exports[`package-type: v1-addon > generator: component > args: --nested --test --typescript 1`] = `
+"[success] Generated component \`foo\` at \`addon/components/foo/index.gts\`.
+[success] Generated component-test \`foo\` at \`tests/integration/components/foo-test.gts\`."
+`;
+
+exports[`package-type: v1-addon > generator: component > args: --nested --test 1`] = `
+"[success] Generated component \`foo\` at \`addon/components/foo/index.gjs\`.
+[success] Generated component-test \`foo\` at \`tests/integration/components/foo-test.gjs\`."
+`;
+
+exports[`package-type: v1-addon > generator: component > args: --nested --typescript 1`] = `"[success] Generated component \`foo\` at \`addon/components/foo/index.gts\`."`;
+
+exports[`package-type: v1-addon > generator: component > args: --nested 1`] = `"[success] Generated component \`foo\` at \`addon/components/foo/index.gjs\`."`;
+
+exports[`package-type: v1-addon > generator: component > args: --test --typescript 1`] = `
+"[success] Generated component \`foo\` at \`addon/components/foo.gts\`.
+[success] Generated component-test \`foo\` at \`tests/integration/components/foo-test.gts\`."
+`;
+
+exports[`package-type: v1-addon > generator: component > args: --test 1`] = `
+"[success] Generated component \`foo\` at \`addon/components/foo.gjs\`.
+[success] Generated component-test \`foo\` at \`tests/integration/components/foo-test.gjs\`."
+`;
+
+exports[`package-type: v1-addon > generator: component > args: --typescript 1`] = `"[success] Generated component \`foo\` at \`addon/components/foo.gts\`."`;
+
+exports[`package-type: v1-addon > generator: component-test > args: --log --typescript 1`] = `
+"[log] import { render } from '@ember/test-helpers';
+import { module, test } from 'qunit';
+import Foo from 'v1-addon/components/foo';
+import { setupRenderingTest } from 'ember-qunit';
+
+module('Integration | Component | Foo', function (hooks) {
+  setupRenderingTest(hooks);
+
+  test('it renders', async function (assert) {
+    await render(<template><Foo /></template>);
+
+    assert.dom().hasText('');
+
+    await render(
+      <template>
+        <Foo>
+          template block text
+        </Foo>
+      </template>
+    );
+
+    assert.dom().hasText('template block text');
+  });
+});
+"
+`;
+
+exports[`package-type: v1-addon > generator: component-test > args: --log 1`] = `
+"[log] import { render } from '@ember/test-helpers';
+import { module, test } from 'qunit';
+import Foo from 'v1-addon/components/foo';
+import { setupRenderingTest } from 'ember-qunit';
+
+module('Integration | Component | Foo', function (hooks) {
+  setupRenderingTest(hooks);
+
+  test('it renders', async function (assert) {
+    await render(<template><Foo /></template>);
+
+    assert.dom().hasText('');
+
+    await render(
+      <template>
+        <Foo>
+          template block text
+        </Foo>
+      </template>
+    );
+
+    assert.dom().hasText('template block text');
+  });
+});
+"
+`;
+
+exports[`package-type: v1-addon > generator: component-test > args: --typescript 1`] = `"[success] Generated component-test \`foo\` at \`tests/integration/components/foo-test.gts\`."`;
+
+exports[`package-type: v1-addon > generator: controller > args: --log --test --typescript 1`] = `
+"[log] import Controller from '@ember/controller';
+
+export default class FooController extends Controller {}
+
+[log] import { module, test } from 'qunit';
+import { setupTest } from 'ember-qunit';
+
+module('Unit | Controller | Foo', function (hooks) {
+  setupTest(hooks);
+
+  test('it exists', function (assert) {
+    const controller = this.owner.lookup('controller:foo');
+
+    assert.ok(controller);
+  });
+});
+"
+`;
+
+exports[`package-type: v1-addon > generator: controller > args: --log --test 1`] = `
+"[log] import Controller from '@ember/controller';
+
+export default class FooController extends Controller {}
+
+[log] import { module, test } from 'qunit';
+import { setupTest } from 'ember-qunit';
+
+module('Unit | Controller | Foo', function (hooks) {
+  setupTest(hooks);
+
+  test('it exists', function (assert) {
+    const controller = this.owner.lookup('controller:foo');
+
+    assert.ok(controller);
+  });
+});
+"
+`;
+
+exports[`package-type: v1-addon > generator: controller > args: --log --typescript 1`] = `
+"[log] import Controller from '@ember/controller';
+
+export default class FooController extends Controller {}
+"
+`;
+
+exports[`package-type: v1-addon > generator: controller > args: --log 1`] = `
+"[log] import Controller from '@ember/controller';
+
+export default class FooController extends Controller {}
+"
+`;
+
+exports[`package-type: v1-addon > generator: controller > args: --test --typescript 1`] = `
+"[success] Generated controller \`foo\` at \`addon/controllers/foo.ts\`.
+[success] Generated controller-test \`foo\` at \`tests/unit/controllers/foo-test.ts\`."
+`;
+
+exports[`package-type: v1-addon > generator: controller > args: --test 1`] = `
+"[success] Generated controller \`foo\` at \`addon/controllers/foo.js\`.
+[success] Generated controller-test \`foo\` at \`tests/unit/controllers/foo-test.js\`."
+`;
+
+exports[`package-type: v1-addon > generator: controller > args: --typescript 1`] = `"[success] Generated controller \`foo\` at \`addon/controllers/foo.ts\`."`;
+
+exports[`package-type: v1-addon > generator: controller-test > args: --log --typescript 1`] = `
+"[log] import { module, test } from 'qunit';
+import { setupTest } from 'ember-qunit';
+
+module('Unit | Controller | Foo', function (hooks) {
+  setupTest(hooks);
+
+  test('it exists', function (assert) {
+    const controller = this.owner.lookup('controller:foo');
+
+    assert.ok(controller);
+  });
+});
+"
+`;
+
+exports[`package-type: v1-addon > generator: controller-test > args: --log 1`] = `
+"[log] import { module, test } from 'qunit';
+import { setupTest } from 'ember-qunit';
+
+module('Unit | Controller | Foo', function (hooks) {
+  setupTest(hooks);
+
+  test('it exists', function (assert) {
+    const controller = this.owner.lookup('controller:foo');
+
+    assert.ok(controller);
+  });
+});
+"
+`;
+
+exports[`package-type: v1-addon > generator: controller-test > args: --typescript 1`] = `"[success] Generated controller-test \`foo\` at \`tests/unit/controllers/foo-test.ts\`."`;
+
+exports[`package-type: v1-addon > generator: helper > args: --classBased --log --namedExport --test --typescript 1`] = `
+"[log] import Helper from '@ember/component/helper';
+
+type Named = {};
+type Positional = [];
+type Return = Positional;
+
+export interface FooSignature {
+  Args: {
+    Named: Named;
+    Positional: Positional;
+  };
+  Return: Return;
+}
+
+export class foo extends Helper<FooSignature> {
+  compute(positional: Positional, named: Named): Return {
+    return positional;
+  }
+}
+
+[log] import { render } from '@ember/test-helpers';
+import { module, test } from 'qunit';
+import foo from 'v1-addon/helpers/foo';
+import { setupRenderingTest } from 'ember-qunit';
+
+module('Integration | Helper | foo', function (hooks) {
+  setupRenderingTest(hooks);
+
+  test('it renders', async function (assert) {
+    const inputValue = '1234';
+
+    await render(<template>{{foo inputValue}}</template>);
+
+    assert.dom().hasText('1234');
+  });
+});
+"
+`;
+
+exports[`package-type: v1-addon > generator: helper > args: --classBased --log --namedExport --test 1`] = `
+"[log] import Helper from '@ember/component/helper';
+
+export class foo extends Helper {
+  compute(positional, named) {
+    return positional;
+  }
+}
+
+[log] import { render } from '@ember/test-helpers';
+import { module, test } from 'qunit';
+import foo from 'v1-addon/helpers/foo';
+import { setupRenderingTest } from 'ember-qunit';
+
+module('Integration | Helper | foo', function (hooks) {
+  setupRenderingTest(hooks);
+
+  test('it renders', async function (assert) {
+    const inputValue = '1234';
+
+    await render(<template>{{foo inputValue}}</template>);
+
+    assert.dom().hasText('1234');
+  });
+});
+"
+`;
+
+exports[`package-type: v1-addon > generator: helper > args: --classBased --log --namedExport --typescript 1`] = `
+"[log] import Helper from '@ember/component/helper';
+
+type Named = {};
+type Positional = [];
+type Return = Positional;
+
+export interface FooSignature {
+  Args: {
+    Named: Named;
+    Positional: Positional;
+  };
+  Return: Return;
+}
+
+export class foo extends Helper<FooSignature> {
+  compute(positional: Positional, named: Named): Return {
+    return positional;
+  }
+}
+"
+`;
+
+exports[`package-type: v1-addon > generator: helper > args: --classBased --log --namedExport 1`] = `
+"[log] import Helper from '@ember/component/helper';
+
+export class foo extends Helper {
+  compute(positional, named) {
+    return positional;
+  }
+}
+"
+`;
+
+exports[`package-type: v1-addon > generator: helper > args: --classBased --log --test --typescript 1`] = `
+"[log] import Helper from '@ember/component/helper';
+
+type Named = {};
+type Positional = [];
+type Return = Positional;
+
+export interface FooSignature {
+  Args: {
+    Named: Named;
+    Positional: Positional;
+  };
+  Return: Return;
+}
+
+export default class foo extends Helper<FooSignature> {
+  compute(positional: Positional, named: Named): Return {
+    return positional;
+  }
+}
+
+[log] import { render } from '@ember/test-helpers';
+import { module, test } from 'qunit';
+import foo from 'v1-addon/helpers/foo';
+import { setupRenderingTest } from 'ember-qunit';
+
+module('Integration | Helper | foo', function (hooks) {
+  setupRenderingTest(hooks);
+
+  test('it renders', async function (assert) {
+    const inputValue = '1234';
+
+    await render(<template>{{foo inputValue}}</template>);
+
+    assert.dom().hasText('1234');
+  });
+});
+"
+`;
+
+exports[`package-type: v1-addon > generator: helper > args: --classBased --log --test 1`] = `
+"[log] import Helper from '@ember/component/helper';
+
+export default class foo extends Helper {
+  compute(positional, named) {
+    return positional;
+  }
+}
+
+[log] import { render } from '@ember/test-helpers';
+import { module, test } from 'qunit';
+import foo from 'v1-addon/helpers/foo';
+import { setupRenderingTest } from 'ember-qunit';
+
+module('Integration | Helper | foo', function (hooks) {
+  setupRenderingTest(hooks);
+
+  test('it renders', async function (assert) {
+    const inputValue = '1234';
+
+    await render(<template>{{foo inputValue}}</template>);
+
+    assert.dom().hasText('1234');
+  });
+});
+"
+`;
+
+exports[`package-type: v1-addon > generator: helper > args: --classBased --log --typescript 1`] = `
+"[log] import Helper from '@ember/component/helper';
+
+type Named = {};
+type Positional = [];
+type Return = Positional;
+
+export interface FooSignature {
+  Args: {
+    Named: Named;
+    Positional: Positional;
+  };
+  Return: Return;
+}
+
+export default class foo extends Helper<FooSignature> {
+  compute(positional: Positional, named: Named): Return {
+    return positional;
+  }
+}
+"
+`;
+
+exports[`package-type: v1-addon > generator: helper > args: --classBased --log 1`] = `
+"[log] import Helper from '@ember/component/helper';
+
+export default class foo extends Helper {
+  compute(positional, named) {
+    return positional;
+  }
+}
+"
+`;
+
+exports[`package-type: v1-addon > generator: helper > args: --classBased --namedExport --test --typescript 1`] = `
+"[success] Generated helper \`foo\` at \`addon/helpers/foo.ts\`.
+[success] Generated helper-test \`foo\` at \`tests/integration/helpers/foo-test.gts\`."
+`;
+
+exports[`package-type: v1-addon > generator: helper > args: --classBased --namedExport --test 1`] = `
+"[success] Generated helper \`foo\` at \`addon/helpers/foo.js\`.
+[success] Generated helper-test \`foo\` at \`tests/integration/helpers/foo-test.gjs\`."
+`;
+
+exports[`package-type: v1-addon > generator: helper > args: --classBased --namedExport --typescript 1`] = `"[success] Generated helper \`foo\` at \`addon/helpers/foo.ts\`."`;
+
+exports[`package-type: v1-addon > generator: helper > args: --classBased --namedExport 1`] = `"[success] Generated helper \`foo\` at \`addon/helpers/foo.js\`."`;
+
+exports[`package-type: v1-addon > generator: helper > args: --classBased --test --typescript 1`] = `
+"[success] Generated helper \`foo\` at \`addon/helpers/foo.ts\`.
+[success] Generated helper-test \`foo\` at \`tests/integration/helpers/foo-test.gts\`."
+`;
+
+exports[`package-type: v1-addon > generator: helper > args: --classBased --test 1`] = `
+"[success] Generated helper \`foo\` at \`addon/helpers/foo.js\`.
+[success] Generated helper-test \`foo\` at \`tests/integration/helpers/foo-test.gjs\`."
+`;
+
+exports[`package-type: v1-addon > generator: helper > args: --classBased --typescript 1`] = `"[success] Generated helper \`foo\` at \`addon/helpers/foo.ts\`."`;
+
+exports[`package-type: v1-addon > generator: helper > args: --classBased 1`] = `"[success] Generated helper \`foo\` at \`addon/helpers/foo.js\`."`;
+
+exports[`package-type: v1-addon > generator: helper > args: --log --namedExport --test --typescript 1`] = `
+"[log] export function foo(positional, named) {
+  return positional;
+}
+
+[log] import { render } from '@ember/test-helpers';
+import { module, test } from 'qunit';
+import foo from 'v1-addon/helpers/foo';
+import { setupRenderingTest } from 'ember-qunit';
+
+module('Integration | Helper | foo', function (hooks) {
+  setupRenderingTest(hooks);
+
+  test('it renders', async function (assert) {
+    const inputValue = '1234';
+
+    await render(<template>{{foo inputValue}}</template>);
+
+    assert.dom().hasText('1234');
+  });
+});
+"
+`;
+
+exports[`package-type: v1-addon > generator: helper > args: --log --namedExport --test 1`] = `
+"[log] export function foo(positional, named) {
+  return positional;
+}
+
+[log] import { render } from '@ember/test-helpers';
+import { module, test } from 'qunit';
+import foo from 'v1-addon/helpers/foo';
+import { setupRenderingTest } from 'ember-qunit';
+
+module('Integration | Helper | foo', function (hooks) {
+  setupRenderingTest(hooks);
+
+  test('it renders', async function (assert) {
+    const inputValue = '1234';
+
+    await render(<template>{{foo inputValue}}</template>);
+
+    assert.dom().hasText('1234');
+  });
+});
+"
+`;
+
+exports[`package-type: v1-addon > generator: helper > args: --log --namedExport --typescript 1`] = `
+"[log] export function foo(positional, named) {
+  return positional;
+}
+"
+`;
+
+exports[`package-type: v1-addon > generator: helper > args: --log --namedExport 1`] = `
+"[log] export function foo(positional, named) {
+  return positional;
+}
+"
+`;
+
+exports[`package-type: v1-addon > generator: helper > args: --log --test --typescript 1`] = `
+"[log] export default function foo(positional, named) {
+  return positional;
+}
+
+[log] import { render } from '@ember/test-helpers';
+import { module, test } from 'qunit';
+import foo from 'v1-addon/helpers/foo';
+import { setupRenderingTest } from 'ember-qunit';
+
+module('Integration | Helper | foo', function (hooks) {
+  setupRenderingTest(hooks);
+
+  test('it renders', async function (assert) {
+    const inputValue = '1234';
+
+    await render(<template>{{foo inputValue}}</template>);
+
+    assert.dom().hasText('1234');
+  });
+});
+"
+`;
+
+exports[`package-type: v1-addon > generator: helper > args: --log --test 1`] = `
+"[log] export default function foo(positional, named) {
+  return positional;
+}
+
+[log] import { render } from '@ember/test-helpers';
+import { module, test } from 'qunit';
+import foo from 'v1-addon/helpers/foo';
+import { setupRenderingTest } from 'ember-qunit';
+
+module('Integration | Helper | foo', function (hooks) {
+  setupRenderingTest(hooks);
+
+  test('it renders', async function (assert) {
+    const inputValue = '1234';
+
+    await render(<template>{{foo inputValue}}</template>);
+
+    assert.dom().hasText('1234');
+  });
+});
+"
+`;
+
+exports[`package-type: v1-addon > generator: helper > args: --log --typescript 1`] = `
+"[log] export default function foo(positional, named) {
+  return positional;
+}
+"
+`;
+
+exports[`package-type: v1-addon > generator: helper > args: --log 1`] = `
+"[log] export default function foo(positional, named) {
+  return positional;
+}
+"
+`;
+
+exports[`package-type: v1-addon > generator: helper > args: --namedExport --test --typescript 1`] = `
+"[success] Generated helper \`foo\` at \`addon/helpers/foo.ts\`.
+[success] Generated helper-test \`foo\` at \`tests/integration/helpers/foo-test.gts\`."
+`;
+
+exports[`package-type: v1-addon > generator: helper > args: --namedExport --test 1`] = `
+"[success] Generated helper \`foo\` at \`addon/helpers/foo.js\`.
+[success] Generated helper-test \`foo\` at \`tests/integration/helpers/foo-test.gjs\`."
+`;
+
+exports[`package-type: v1-addon > generator: helper > args: --namedExport --typescript 1`] = `"[success] Generated helper \`foo\` at \`addon/helpers/foo.ts\`."`;
+
+exports[`package-type: v1-addon > generator: helper > args: --namedExport 1`] = `"[success] Generated helper \`foo\` at \`addon/helpers/foo.js\`."`;
+
+exports[`package-type: v1-addon > generator: helper > args: --test --typescript 1`] = `
+"[success] Generated helper \`foo\` at \`addon/helpers/foo.ts\`.
+[success] Generated helper-test \`foo\` at \`tests/integration/helpers/foo-test.gts\`."
+`;
+
+exports[`package-type: v1-addon > generator: helper > args: --test 1`] = `
+"[success] Generated helper \`foo\` at \`addon/helpers/foo.js\`.
+[success] Generated helper-test \`foo\` at \`tests/integration/helpers/foo-test.gjs\`."
+`;
+
+exports[`package-type: v1-addon > generator: helper > args: --typescript 1`] = `"[success] Generated helper \`foo\` at \`addon/helpers/foo.ts\`."`;
+
+exports[`package-type: v1-addon > generator: helper-test > args: --log --typescript 1`] = `
+"[log] import { render } from '@ember/test-helpers';
+import { module, test } from 'qunit';
+import foo from 'v1-addon/helpers/foo';
+import { setupRenderingTest } from 'ember-qunit';
+
+module('Integration | Helper | foo', function (hooks) {
+  setupRenderingTest(hooks);
+
+  test('it renders', async function (assert) {
+    const inputValue = '1234';
+
+    await render(<template>{{foo inputValue}}</template>);
+
+    assert.dom().hasText('1234');
+  });
+});
+"
+`;
+
+exports[`package-type: v1-addon > generator: helper-test > args: --log 1`] = `
+"[log] import { render } from '@ember/test-helpers';
+import { module, test } from 'qunit';
+import foo from 'v1-addon/helpers/foo';
+import { setupRenderingTest } from 'ember-qunit';
+
+module('Integration | Helper | foo', function (hooks) {
+  setupRenderingTest(hooks);
+
+  test('it renders', async function (assert) {
+    const inputValue = '1234';
+
+    await render(<template>{{foo inputValue}}</template>);
+
+    assert.dom().hasText('1234');
+  });
+});
+"
+`;
+
+exports[`package-type: v1-addon > generator: helper-test > args: --typescript 1`] = `"[success] Generated helper-test \`foo\` at \`tests/integration/helpers/foo-test.gts\`."`;
+
+exports[`package-type: v1-addon > generator: modifier > args: --classBased --log --namedExport --test --typescript 1`] = `
+"[log] import Modifier from 'ember-modifier';
+
+type Named = {};
+type Positional = [];
+type Element = null;
+
+export interface FooSignature {
+  Args: {
+    Named: Named;
+    Positional: Positional;
+  };
+  Element: Element;
+}
+
+export class foo extends Modifier<FooSignature> {
+  modify(element: Element, positional: Positional, named: Named) {}
+}
+
+[log] import { render } from '@ember/test-helpers';
+import { module, test } from 'qunit';
+import foo from 'v1-addon/modifiers/foo';
+import { setupRenderingTest } from 'ember-qunit';
+
+module('Integration | Modifier | foo', function (hooks) {
+  setupRenderingTest(hooks);
+
+  test('it renders', async function (assert) {
+    await render(
+      <template>
+        <div {{foo}}></div>
+      </template>
+    );
+
+    assert.ok(true);
+  });
+});
+"
+`;
+
+exports[`package-type: v1-addon > generator: modifier > args: --classBased --log --namedExport --test 1`] = `
+"[log] import Modifier from 'ember-modifier';
+
+export class foo extends Modifier {
+  modify(element, positional, named) {}
+}
+
+[log] import { render } from '@ember/test-helpers';
+import { module, test } from 'qunit';
+import foo from 'v1-addon/modifiers/foo';
+import { setupRenderingTest } from 'ember-qunit';
+
+module('Integration | Modifier | foo', function (hooks) {
+  setupRenderingTest(hooks);
+
+  test('it renders', async function (assert) {
+    await render(
+      <template>
+        <div {{foo}}></div>
+      </template>
+    );
+
+    assert.ok(true);
+  });
+});
+"
+`;
+
+exports[`package-type: v1-addon > generator: modifier > args: --classBased --log --namedExport --typescript 1`] = `
+"[log] import Modifier from 'ember-modifier';
+
+type Named = {};
+type Positional = [];
+type Element = null;
+
+export interface FooSignature {
+  Args: {
+    Named: Named;
+    Positional: Positional;
+  };
+  Element: Element;
+}
+
+export class foo extends Modifier<FooSignature> {
+  modify(element: Element, positional: Positional, named: Named) {}
+}
+"
+`;
+
+exports[`package-type: v1-addon > generator: modifier > args: --classBased --log --namedExport 1`] = `
+"[log] import Modifier from 'ember-modifier';
+
+export class foo extends Modifier {
+  modify(element, positional, named) {}
+}
+"
+`;
+
+exports[`package-type: v1-addon > generator: modifier > args: --classBased --log --test --typescript 1`] = `
+"[log] import Modifier from 'ember-modifier';
+
+type Named = {};
+type Positional = [];
+type Element = null;
+
+export interface FooSignature {
+  Args: {
+    Named: Named;
+    Positional: Positional;
+  };
+  Element: Element;
+}
+
+export default class foo extends Modifier<FooSignature> {
+  modify(element: Element, positional: Positional, named: Named) {}
+}
+
+[log] import { render } from '@ember/test-helpers';
+import { module, test } from 'qunit';
+import foo from 'v1-addon/modifiers/foo';
+import { setupRenderingTest } from 'ember-qunit';
+
+module('Integration | Modifier | foo', function (hooks) {
+  setupRenderingTest(hooks);
+
+  test('it renders', async function (assert) {
+    await render(
+      <template>
+        <div {{foo}}></div>
+      </template>
+    );
+
+    assert.ok(true);
+  });
+});
+"
+`;
+
+exports[`package-type: v1-addon > generator: modifier > args: --classBased --log --test 1`] = `
+"[log] import Modifier from 'ember-modifier';
+
+export default class foo extends Modifier {
+  modify(element, positional, named) {}
+}
+
+[log] import { render } from '@ember/test-helpers';
+import { module, test } from 'qunit';
+import foo from 'v1-addon/modifiers/foo';
+import { setupRenderingTest } from 'ember-qunit';
+
+module('Integration | Modifier | foo', function (hooks) {
+  setupRenderingTest(hooks);
+
+  test('it renders', async function (assert) {
+    await render(
+      <template>
+        <div {{foo}}></div>
+      </template>
+    );
+
+    assert.ok(true);
+  });
+});
+"
+`;
+
+exports[`package-type: v1-addon > generator: modifier > args: --classBased --log --typescript 1`] = `
+"[log] import Modifier from 'ember-modifier';
+
+type Named = {};
+type Positional = [];
+type Element = null;
+
+export interface FooSignature {
+  Args: {
+    Named: Named;
+    Positional: Positional;
+  };
+  Element: Element;
+}
+
+export default class foo extends Modifier<FooSignature> {
+  modify(element: Element, positional: Positional, named: Named) {}
+}
+"
+`;
+
+exports[`package-type: v1-addon > generator: modifier > args: --classBased --log 1`] = `
+"[log] import Modifier from 'ember-modifier';
+
+export default class foo extends Modifier {
+  modify(element, positional, named) {}
+}
+"
+`;
+
+exports[`package-type: v1-addon > generator: modifier > args: --classBased --namedExport --test --typescript 1`] = `
+"[success] Generated modifier \`foo\` at \`addon/modifiers/foo.ts\`.
+[success] Generated modifier-test \`foo\` at \`tests/integration/modifiers/foo-test.gts\`."
+`;
+
+exports[`package-type: v1-addon > generator: modifier > args: --classBased --namedExport --test 1`] = `
+"[success] Generated modifier \`foo\` at \`addon/modifiers/foo.js\`.
+[success] Generated modifier-test \`foo\` at \`tests/integration/modifiers/foo-test.gjs\`."
+`;
+
+exports[`package-type: v1-addon > generator: modifier > args: --classBased --namedExport --typescript 1`] = `"[success] Generated modifier \`foo\` at \`addon/modifiers/foo.ts\`."`;
+
+exports[`package-type: v1-addon > generator: modifier > args: --classBased --namedExport 1`] = `"[success] Generated modifier \`foo\` at \`addon/modifiers/foo.js\`."`;
+
+exports[`package-type: v1-addon > generator: modifier > args: --classBased --test --typescript 1`] = `
+"[success] Generated modifier \`foo\` at \`addon/modifiers/foo.ts\`.
+[success] Generated modifier-test \`foo\` at \`tests/integration/modifiers/foo-test.gts\`."
+`;
+
+exports[`package-type: v1-addon > generator: modifier > args: --classBased --test 1`] = `
+"[success] Generated modifier \`foo\` at \`addon/modifiers/foo.js\`.
+[success] Generated modifier-test \`foo\` at \`tests/integration/modifiers/foo-test.gjs\`."
+`;
+
+exports[`package-type: v1-addon > generator: modifier > args: --classBased --typescript 1`] = `"[success] Generated modifier \`foo\` at \`addon/modifiers/foo.ts\`."`;
+
+exports[`package-type: v1-addon > generator: modifier > args: --classBased 1`] = `"[success] Generated modifier \`foo\` at \`addon/modifiers/foo.js\`."`;
+
+exports[`package-type: v1-addon > generator: modifier > args: --log --namedExport --test --typescript 1`] = `
+"[log] import { modifier } from 'ember-modifier';
+
+export interface FooSignature {
+  Args: {
+    Named: {};
+    Positional: [];
+  };
+  Element: null;
+}
+
+export const foo = modifier<FooSignature>(function foo(element, positional, named) {});
+
+[log] import { render } from '@ember/test-helpers';
+import { module, test } from 'qunit';
+import foo from 'v1-addon/modifiers/foo';
+import { setupRenderingTest } from 'ember-qunit';
+
+module('Integration | Modifier | foo', function (hooks) {
+  setupRenderingTest(hooks);
+
+  test('it renders', async function (assert) {
+    await render(
+      <template>
+        <div {{foo}}></div>
+      </template>
+    );
+
+    assert.ok(true);
+  });
+});
+"
+`;
+
+exports[`package-type: v1-addon > generator: modifier > args: --log --namedExport --test 1`] = `
+"[log] import { modifier } from 'ember-modifier';
+
+export const foo = modifier(function foo(element, positional, named) {});
+
+[log] import { render } from '@ember/test-helpers';
+import { module, test } from 'qunit';
+import foo from 'v1-addon/modifiers/foo';
+import { setupRenderingTest } from 'ember-qunit';
+
+module('Integration | Modifier | foo', function (hooks) {
+  setupRenderingTest(hooks);
+
+  test('it renders', async function (assert) {
+    await render(
+      <template>
+        <div {{foo}}></div>
+      </template>
+    );
+
+    assert.ok(true);
+  });
+});
+"
+`;
+
+exports[`package-type: v1-addon > generator: modifier > args: --log --namedExport --typescript 1`] = `
+"[log] import { modifier } from 'ember-modifier';
+
+export interface FooSignature {
+  Args: {
+    Named: {};
+    Positional: [];
+  };
+  Element: null;
+}
+
+export const foo = modifier<FooSignature>(function foo(element, positional, named) {});
+"
+`;
+
+exports[`package-type: v1-addon > generator: modifier > args: --log --namedExport 1`] = `
+"[log] import { modifier } from 'ember-modifier';
+
+export const foo = modifier(function foo(element, positional, named) {});
+"
+`;
+
+exports[`package-type: v1-addon > generator: modifier > args: --log --test --typescript 1`] = `
+"[log] import { modifier } from 'ember-modifier';
+
+export interface FooSignature {
+  Args: {
+    Named: {};
+    Positional: [];
+  };
+  Element: null;
+}
+
+export default modifier<FooSignature>(function foo(element, positional, named) {});
+
+[log] import { render } from '@ember/test-helpers';
+import { module, test } from 'qunit';
+import foo from 'v1-addon/modifiers/foo';
+import { setupRenderingTest } from 'ember-qunit';
+
+module('Integration | Modifier | foo', function (hooks) {
+  setupRenderingTest(hooks);
+
+  test('it renders', async function (assert) {
+    await render(
+      <template>
+        <div {{foo}}></div>
+      </template>
+    );
+
+    assert.ok(true);
+  });
+});
+"
+`;
+
+exports[`package-type: v1-addon > generator: modifier > args: --log --test 1`] = `
+"[log] import { modifier } from 'ember-modifier';
+
+export default modifier(function foo(element, positional, named) {});
+
+[log] import { render } from '@ember/test-helpers';
+import { module, test } from 'qunit';
+import foo from 'v1-addon/modifiers/foo';
+import { setupRenderingTest } from 'ember-qunit';
+
+module('Integration | Modifier | foo', function (hooks) {
+  setupRenderingTest(hooks);
+
+  test('it renders', async function (assert) {
+    await render(
+      <template>
+        <div {{foo}}></div>
+      </template>
+    );
+
+    assert.ok(true);
+  });
+});
+"
+`;
+
+exports[`package-type: v1-addon > generator: modifier > args: --log --typescript 1`] = `
+"[log] import { modifier } from 'ember-modifier';
+
+export interface FooSignature {
+  Args: {
+    Named: {};
+    Positional: [];
+  };
+  Element: null;
+}
+
+export default modifier<FooSignature>(function foo(element, positional, named) {});
+"
+`;
+
+exports[`package-type: v1-addon > generator: modifier > args: --log 1`] = `
+"[log] import { modifier } from 'ember-modifier';
+
+export default modifier(function foo(element, positional, named) {});
+"
+`;
+
+exports[`package-type: v1-addon > generator: modifier > args: --namedExport --test --typescript 1`] = `
+"[success] Generated modifier \`foo\` at \`addon/modifiers/foo.ts\`.
+[success] Generated modifier-test \`foo\` at \`tests/integration/modifiers/foo-test.gts\`."
+`;
+
+exports[`package-type: v1-addon > generator: modifier > args: --namedExport --test 1`] = `
+"[success] Generated modifier \`foo\` at \`addon/modifiers/foo.js\`.
+[success] Generated modifier-test \`foo\` at \`tests/integration/modifiers/foo-test.gjs\`."
+`;
+
+exports[`package-type: v1-addon > generator: modifier > args: --namedExport --typescript 1`] = `"[success] Generated modifier \`foo\` at \`addon/modifiers/foo.ts\`."`;
+
+exports[`package-type: v1-addon > generator: modifier > args: --namedExport 1`] = `"[success] Generated modifier \`foo\` at \`addon/modifiers/foo.js\`."`;
+
+exports[`package-type: v1-addon > generator: modifier > args: --test --typescript 1`] = `
+"[success] Generated modifier \`foo\` at \`addon/modifiers/foo.ts\`.
+[success] Generated modifier-test \`foo\` at \`tests/integration/modifiers/foo-test.gts\`."
+`;
+
+exports[`package-type: v1-addon > generator: modifier > args: --test 1`] = `
+"[success] Generated modifier \`foo\` at \`addon/modifiers/foo.js\`.
+[success] Generated modifier-test \`foo\` at \`tests/integration/modifiers/foo-test.gjs\`."
+`;
+
+exports[`package-type: v1-addon > generator: modifier > args: --typescript 1`] = `"[success] Generated modifier \`foo\` at \`addon/modifiers/foo.ts\`."`;
+
+exports[`package-type: v1-addon > generator: modifier-test > args: --log --typescript 1`] = `
+"[log] import { render } from '@ember/test-helpers';
+import { module, test } from 'qunit';
+import foo from 'v1-addon/modifiers/foo';
+import { setupRenderingTest } from 'ember-qunit';
+
+module('Integration | Modifier | foo', function (hooks) {
+  setupRenderingTest(hooks);
+
+  test('it renders', async function (assert) {
+    await render(
+      <template>
+        <div {{foo}}></div>
+      </template>
+    );
+
+    assert.ok(true);
+  });
+});
+"
+`;
+
+exports[`package-type: v1-addon > generator: modifier-test > args: --log 1`] = `
+"[log] import { render } from '@ember/test-helpers';
+import { module, test } from 'qunit';
+import foo from 'v1-addon/modifiers/foo';
+import { setupRenderingTest } from 'ember-qunit';
+
+module('Integration | Modifier | foo', function (hooks) {
+  setupRenderingTest(hooks);
+
+  test('it renders', async function (assert) {
+    await render(
+      <template>
+        <div {{foo}}></div>
+      </template>
+    );
+
+    assert.ok(true);
+  });
+});
+"
+`;
+
+exports[`package-type: v1-addon > generator: modifier-test > args: --typescript 1`] = `"[success] Generated modifier-test \`foo\` at \`tests/integration/modifiers/foo-test.gts\`."`;
+
+exports[`package-type: v1-addon > generator: route > args: --log --test --typescript 1`] = `
+"[log] import Route from '@ember/routing/route';
+
+export default class FooRoute extends Route {}
+
+[log] import { module, test } from 'qunit';
+import { setupTest } from 'ember-qunit';
+
+module('Unit | Route | Foo', function (hooks) {
+  setupTest(hooks);
+
+  test('it exists', function (assert) {
+    const route = this.owner.lookup('route:foo');
+
+    assert.ok(route);
+  });
+});
+"
+`;
+
+exports[`package-type: v1-addon > generator: route > args: --log --test 1`] = `
+"[log] import Route from '@ember/routing/route';
+
+export default class FooRoute extends Route {}
+
+[log] import { module, test } from 'qunit';
+import { setupTest } from 'ember-qunit';
+
+module('Unit | Route | Foo', function (hooks) {
+  setupTest(hooks);
+
+  test('it exists', function (assert) {
+    const route = this.owner.lookup('route:foo');
+
+    assert.ok(route);
+  });
+});
+"
+`;
+
+exports[`package-type: v1-addon > generator: route > args: --log --typescript 1`] = `
+"[log] import Route from '@ember/routing/route';
+
+export default class FooRoute extends Route {}
+"
+`;
+
+exports[`package-type: v1-addon > generator: route > args: --log 1`] = `
+"[log] import Route from '@ember/routing/route';
+
+export default class FooRoute extends Route {}
+"
+`;
+
+exports[`package-type: v1-addon > generator: route > args: --test --typescript 1`] = `
+"[success] Generated route \`foo\` at \`addon/routes/foo.ts\`.
+[success] Generated route-test \`foo\` at \`tests/unit/routes/foo-test.ts\`."
+`;
+
+exports[`package-type: v1-addon > generator: route > args: --test 1`] = `
+"[success] Generated route \`foo\` at \`addon/routes/foo.js\`.
+[success] Generated route-test \`foo\` at \`tests/unit/routes/foo-test.js\`."
+`;
+
+exports[`package-type: v1-addon > generator: route > args: --typescript 1`] = `"[success] Generated route \`foo\` at \`addon/routes/foo.ts\`."`;
+
+exports[`package-type: v1-addon > generator: route-test > args: --log --typescript 1`] = `
+"[log] import { module, test } from 'qunit';
+import { setupTest } from 'ember-qunit';
+
+module('Unit | Route | Foo', function (hooks) {
+  setupTest(hooks);
+
+  test('it exists', function (assert) {
+    const route = this.owner.lookup('route:foo');
+
+    assert.ok(route);
+  });
+});
+"
+`;
+
+exports[`package-type: v1-addon > generator: route-test > args: --log 1`] = `
+"[log] import { module, test } from 'qunit';
+import { setupTest } from 'ember-qunit';
+
+module('Unit | Route | Foo', function (hooks) {
+  setupTest(hooks);
+
+  test('it exists', function (assert) {
+    const route = this.owner.lookup('route:foo');
+
+    assert.ok(route);
+  });
+});
+"
+`;
+
+exports[`package-type: v1-addon > generator: route-test > args: --typescript 1`] = `"[success] Generated route-test \`foo\` at \`tests/unit/routes/foo-test.ts\`."`;
+
+exports[`package-type: v1-addon > generator: service > args: --log --test --typescript 1`] = `
+"[log] import Service from '@ember/service';
+
+export default class FooService extends Service {}
+
+declare module '@ember/service' {
+  interface Registry {
+    foo: FooService;
+  }
+}
+
+[log] import { module, test } from 'qunit';
+import { setupTest } from 'ember-qunit';
+
+module('Unit | Service | Foo', function (hooks) {
+  setupTest(hooks);
+
+  test('it exists', function (assert) {
+    const service = this.owner.lookup('service:foo');
+
+    assert.ok(service);
+  });
+});
+"
+`;
+
+exports[`package-type: v1-addon > generator: service > args: --log --test 1`] = `
+"[log] import Service from '@ember/service';
+
+export default class FooService extends Service {}
+
+[log] import { module, test } from 'qunit';
+import { setupTest } from 'ember-qunit';
+
+module('Unit | Service | Foo', function (hooks) {
+  setupTest(hooks);
+
+  test('it exists', function (assert) {
+    const service = this.owner.lookup('service:foo');
+
+    assert.ok(service);
+  });
+});
+"
+`;
+
+exports[`package-type: v1-addon > generator: service > args: --log --typescript 1`] = `
+"[log] import Service from '@ember/service';
+
+export default class FooService extends Service {}
+
+declare module '@ember/service' {
+  interface Registry {
+    foo: FooService;
+  }
+}
+"
+`;
+
+exports[`package-type: v1-addon > generator: service > args: --log 1`] = `
+"[log] import Service from '@ember/service';
+
+export default class FooService extends Service {}
+"
+`;
+
+exports[`package-type: v1-addon > generator: service > args: --test --typescript 1`] = `
+"[success] Generated service \`foo\` at \`addon/services/foo.ts\`.
+[success] Generated service-test \`foo\` at \`tests/unit/services/foo-test.ts\`."
+`;
+
+exports[`package-type: v1-addon > generator: service > args: --test 1`] = `
+"[success] Generated service \`foo\` at \`addon/services/foo.js\`.
+[success] Generated service-test \`foo\` at \`tests/unit/services/foo-test.js\`."
+`;
+
+exports[`package-type: v1-addon > generator: service > args: --typescript 1`] = `"[success] Generated service \`foo\` at \`addon/services/foo.ts\`."`;
+
+exports[`package-type: v1-addon > generator: service-test > args: --log --typescript 1`] = `
+"[log] import { module, test } from 'qunit';
+import { setupTest } from 'ember-qunit';
+
+module('Unit | Service | Foo', function (hooks) {
+  setupTest(hooks);
+
+  test('it exists', function (assert) {
+    const service = this.owner.lookup('service:foo');
+
+    assert.ok(service);
+  });
+});
+"
+`;
+
+exports[`package-type: v1-addon > generator: service-test > args: --log 1`] = `
+"[log] import { module, test } from 'qunit';
+import { setupTest } from 'ember-qunit';
+
+module('Unit | Service | Foo', function (hooks) {
+  setupTest(hooks);
+
+  test('it exists', function (assert) {
+    const service = this.owner.lookup('service:foo');
+
+    assert.ok(service);
+  });
+});
+"
+`;
+
+exports[`package-type: v1-addon > generator: service-test > args: --typescript 1`] = `"[success] Generated service-test \`foo\` at \`tests/unit/services/foo-test.ts\`."`;
+
+exports[`package-type: v1-addon > generator: util > args: --log --namedExport --test --typescript 1`] = `
+"[log] export function foo() {
+  return true;
+}
+
+[log] import foo from 'v1-addon/utils/foo';
+import { module, test } from 'qunit';
+
+module('Unit | Util | foo', function () {
+  test('it works', function (assert) {
+    const result = foo();
+
+    assert.ok(result);
+  });
+});
+"
+`;
+
+exports[`package-type: v1-addon > generator: util > args: --log --namedExport --test 1`] = `
+"[log] export function foo() {
+  return true;
+}
+
+[log] import foo from 'v1-addon/utils/foo';
+import { module, test } from 'qunit';
+
+module('Unit | Util | foo', function () {
+  test('it works', function (assert) {
+    const result = foo();
+
+    assert.ok(result);
+  });
+});
+"
+`;
+
+exports[`package-type: v1-addon > generator: util > args: --log --namedExport --typescript 1`] = `
+"[log] export function foo() {
+  return true;
+}
+"
+`;
+
+exports[`package-type: v1-addon > generator: util > args: --log --namedExport 1`] = `
+"[log] export function foo() {
+  return true;
+}
+"
+`;
+
+exports[`package-type: v1-addon > generator: util > args: --log --test --typescript 1`] = `
+"[log] export default function foo() {
+  return true;
+}
+
+[log] import foo from 'v1-addon/utils/foo';
+import { module, test } from 'qunit';
+
+module('Unit | Util | foo', function () {
+  test('it works', function (assert) {
+    const result = foo();
+
+    assert.ok(result);
+  });
+});
+"
+`;
+
+exports[`package-type: v1-addon > generator: util > args: --log --test 1`] = `
+"[log] export default function foo() {
+  return true;
+}
+
+[log] import foo from 'v1-addon/utils/foo';
+import { module, test } from 'qunit';
+
+module('Unit | Util | foo', function () {
+  test('it works', function (assert) {
+    const result = foo();
+
+    assert.ok(result);
+  });
+});
+"
+`;
+
+exports[`package-type: v1-addon > generator: util > args: --log --typescript 1`] = `
+"[log] export default function foo() {
+  return true;
+}
+"
+`;
+
+exports[`package-type: v1-addon > generator: util > args: --log 1`] = `
+"[log] export default function foo() {
+  return true;
+}
+"
+`;
+
+exports[`package-type: v1-addon > generator: util > args: --namedExport --test --typescript 1`] = `
+"[success] Generated util \`foo\` at \`addon/utils/foo.ts\`.
+[success] Generated util-test \`foo\` at \`tests/unit/utils/foo-test.ts\`."
+`;
+
+exports[`package-type: v1-addon > generator: util > args: --namedExport --test 1`] = `
+"[success] Generated util \`foo\` at \`addon/utils/foo.js\`.
+[success] Generated util-test \`foo\` at \`tests/unit/utils/foo-test.js\`."
+`;
+
+exports[`package-type: v1-addon > generator: util > args: --namedExport --typescript 1`] = `"[success] Generated util \`foo\` at \`addon/utils/foo.ts\`."`;
+
+exports[`package-type: v1-addon > generator: util > args: --namedExport 1`] = `"[success] Generated util \`foo\` at \`addon/utils/foo.js\`."`;
+
+exports[`package-type: v1-addon > generator: util > args: --test --typescript 1`] = `
+"[success] Generated util \`foo\` at \`addon/utils/foo.ts\`.
+[success] Generated util-test \`foo\` at \`tests/unit/utils/foo-test.ts\`."
+`;
+
+exports[`package-type: v1-addon > generator: util > args: --test 1`] = `
+"[success] Generated util \`foo\` at \`addon/utils/foo.js\`.
+[success] Generated util-test \`foo\` at \`tests/unit/utils/foo-test.js\`."
+`;
+
+exports[`package-type: v1-addon > generator: util > args: --typescript 1`] = `"[success] Generated util \`foo\` at \`addon/utils/foo.ts\`."`;
+
+exports[`package-type: v1-addon > generator: util-test > args: --log --typescript 1`] = `
+"[log] import foo from 'v1-addon/utils/foo';
+import { module, test } from 'qunit';
+
+module('Unit | Util | foo', function () {
+  test('it works', function (assert) {
+    const result = foo();
+
+    assert.ok(result);
+  });
+});
+"
+`;
+
+exports[`package-type: v1-addon > generator: util-test > args: --log 1`] = `
+"[log] import foo from 'v1-addon/utils/foo';
+import { module, test } from 'qunit';
+
+module('Unit | Util | foo', function () {
+  test('it works', function (assert) {
+    const result = foo();
+
+    assert.ok(result);
+  });
+});
+"
+`;
+
+exports[`package-type: v1-addon > generator: util-test > args: --typescript 1`] = `"[success] Generated util-test \`foo\` at \`tests/unit/utils/foo-test.ts\`."`;
+
+exports[`package-type: v1-app > generator: acceptance-test > args: --log --typescript 1`] = `
+"[log] import { currentURL, visit } from '@ember/test-helpers';
+import { module, test } from 'qunit';
+import { setupApplicationTest } from 'ember-qunit';
+
+module('Acceptance | foo', function (hooks) {
+  setupApplicationTest(hooks);
+
+  test('it visits /foo', async function (assert) {
+    await visit('/foo');
+
+    assert.strictEqual(currentURL(), '/foo');
+  });
+});
+"
+`;
+
+exports[`package-type: v1-app > generator: acceptance-test > args: --log 1`] = `
+"[log] import { currentURL, visit } from '@ember/test-helpers';
+import { module, test } from 'qunit';
+import { setupApplicationTest } from 'ember-qunit';
+
+module('Acceptance | foo', function (hooks) {
+  setupApplicationTest(hooks);
+
+  test('it visits /foo', async function (assert) {
+    await visit('/foo');
+
+    assert.strictEqual(currentURL(), '/foo');
+  });
+});
+"
+`;
+
+exports[`package-type: v1-app > generator: acceptance-test > args: --typescript 1`] = `"[success] Generated acceptance-test \`foo\` at \`tests/acceptance/foo-test.ts\`."`;
+
+exports[`package-type: v1-app > generator: component > args: --classBased --log --namedExport --nested --test --typescript 1`] = `
+"[log] import Component from '@glimmer/component';
+
+export interface FooSignature {
+  Args: {};
+  Blocks: {
+    default: [];
+  };
+  Element: null;
+}
+
+export class Foo extends Component<FooSignature> {
+  <template>
+    {{yield}}
+  </template>
+}
+
+[log] import { render } from '@ember/test-helpers';
+import { module, test } from 'qunit';
+import Foo from 'v1-app/components/foo';
+import { setupRenderingTest } from 'ember-qunit';
+
+module('Integration | Component | Foo', function (hooks) {
+  setupRenderingTest(hooks);
+
+  test('it renders', async function (assert) {
+    await render(<template><Foo /></template>);
+
+    assert.dom().hasText('');
+
+    await render(
+      <template>
+        <Foo>
+          template block text
+        </Foo>
+      </template>
+    );
+
+    assert.dom().hasText('template block text');
+  });
+});
+"
+`;
+
+exports[`package-type: v1-app > generator: component > args: --classBased --log --namedExport --nested --test 1`] = `
+"[log] import Component from '@glimmer/component';
+
+export class Foo extends Component {
+  <template>{{yield}}</template>
+}
+
+[log] import { render } from '@ember/test-helpers';
+import { module, test } from 'qunit';
+import Foo from 'v1-app/components/foo';
+import { setupRenderingTest } from 'ember-qunit';
+
+module('Integration | Component | Foo', function (hooks) {
+  setupRenderingTest(hooks);
+
+  test('it renders', async function (assert) {
+    await render(<template><Foo /></template>);
+
+    assert.dom().hasText('');
+
+    await render(
+      <template>
+        <Foo>
+          template block text
+        </Foo>
+      </template>
+    );
+
+    assert.dom().hasText('template block text');
+  });
+});
+"
+`;
+
+exports[`package-type: v1-app > generator: component > args: --classBased --log --namedExport --nested --typescript 1`] = `
+"[log] import Component from '@glimmer/component';
+
+export interface FooSignature {
+  Args: {};
+  Blocks: {
+    default: [];
+  };
+  Element: null;
+}
+
+export class Foo extends Component<FooSignature> {
+  <template>
+    {{yield}}
+  </template>
+}
+"
+`;
+
+exports[`package-type: v1-app > generator: component > args: --classBased --log --namedExport --nested 1`] = `
+"[log] import Component from '@glimmer/component';
+
+export class Foo extends Component {
+  <template>{{yield}}</template>
+}
+"
+`;
+
+exports[`package-type: v1-app > generator: component > args: --classBased --log --namedExport --test --typescript 1`] = `
+"[log] import Component from '@glimmer/component';
+
+export interface FooSignature {
+  Args: {};
+  Blocks: {
+    default: [];
+  };
+  Element: null;
+}
+
+export class Foo extends Component<FooSignature> {
+  <template>
+    {{yield}}
+  </template>
+}
+
+[log] import { render } from '@ember/test-helpers';
+import { module, test } from 'qunit';
+import Foo from 'v1-app/components/foo';
+import { setupRenderingTest } from 'ember-qunit';
+
+module('Integration | Component | Foo', function (hooks) {
+  setupRenderingTest(hooks);
+
+  test('it renders', async function (assert) {
+    await render(<template><Foo /></template>);
+
+    assert.dom().hasText('');
+
+    await render(
+      <template>
+        <Foo>
+          template block text
+        </Foo>
+      </template>
+    );
+
+    assert.dom().hasText('template block text');
+  });
+});
+"
+`;
+
+exports[`package-type: v1-app > generator: component > args: --classBased --log --namedExport --test 1`] = `
+"[log] import Component from '@glimmer/component';
+
+export class Foo extends Component {
+  <template>{{yield}}</template>
+}
+
+[log] import { render } from '@ember/test-helpers';
+import { module, test } from 'qunit';
+import Foo from 'v1-app/components/foo';
+import { setupRenderingTest } from 'ember-qunit';
+
+module('Integration | Component | Foo', function (hooks) {
+  setupRenderingTest(hooks);
+
+  test('it renders', async function (assert) {
+    await render(<template><Foo /></template>);
+
+    assert.dom().hasText('');
+
+    await render(
+      <template>
+        <Foo>
+          template block text
+        </Foo>
+      </template>
+    );
+
+    assert.dom().hasText('template block text');
+  });
+});
+"
+`;
+
+exports[`package-type: v1-app > generator: component > args: --classBased --log --namedExport --typescript 1`] = `
+"[log] import Component from '@glimmer/component';
+
+export interface FooSignature {
+  Args: {};
+  Blocks: {
+    default: [];
+  };
+  Element: null;
+}
+
+export class Foo extends Component<FooSignature> {
+  <template>
+    {{yield}}
+  </template>
+}
+"
+`;
+
+exports[`package-type: v1-app > generator: component > args: --classBased --log --namedExport 1`] = `
+"[log] import Component from '@glimmer/component';
+
+export class Foo extends Component {
+  <template>{{yield}}</template>
+}
+"
+`;
+
+exports[`package-type: v1-app > generator: component > args: --classBased --log --nested --test --typescript 1`] = `
+"[log] import Component from '@glimmer/component';
+
+export interface FooSignature {
+  Args: {};
+  Blocks: {
+    default: [];
+  };
+  Element: null;
+}
+
+export default class Foo extends Component<FooSignature> {
+  <template>
+    {{yield}}
+  </template>
+}
+
+[log] import { render } from '@ember/test-helpers';
+import { module, test } from 'qunit';
+import Foo from 'v1-app/components/foo';
+import { setupRenderingTest } from 'ember-qunit';
+
+module('Integration | Component | Foo', function (hooks) {
+  setupRenderingTest(hooks);
+
+  test('it renders', async function (assert) {
+    await render(<template><Foo /></template>);
+
+    assert.dom().hasText('');
+
+    await render(
+      <template>
+        <Foo>
+          template block text
+        </Foo>
+      </template>
+    );
+
+    assert.dom().hasText('template block text');
+  });
+});
+"
+`;
+
+exports[`package-type: v1-app > generator: component > args: --classBased --log --nested --test 1`] = `
+"[log] import Component from '@glimmer/component';
+
+export default class Foo extends Component {
+  <template>{{yield}}</template>
+}
+
+[log] import { render } from '@ember/test-helpers';
+import { module, test } from 'qunit';
+import Foo from 'v1-app/components/foo';
+import { setupRenderingTest } from 'ember-qunit';
+
+module('Integration | Component | Foo', function (hooks) {
+  setupRenderingTest(hooks);
+
+  test('it renders', async function (assert) {
+    await render(<template><Foo /></template>);
+
+    assert.dom().hasText('');
+
+    await render(
+      <template>
+        <Foo>
+          template block text
+        </Foo>
+      </template>
+    );
+
+    assert.dom().hasText('template block text');
+  });
+});
+"
+`;
+
+exports[`package-type: v1-app > generator: component > args: --classBased --log --nested --typescript 1`] = `
+"[log] import Component from '@glimmer/component';
+
+export interface FooSignature {
+  Args: {};
+  Blocks: {
+    default: [];
+  };
+  Element: null;
+}
+
+export default class Foo extends Component<FooSignature> {
+  <template>
+    {{yield}}
+  </template>
+}
+"
+`;
+
+exports[`package-type: v1-app > generator: component > args: --classBased --log --nested 1`] = `
+"[log] import Component from '@glimmer/component';
+
+export default class Foo extends Component {
+  <template>{{yield}}</template>
+}
+"
+`;
+
+exports[`package-type: v1-app > generator: component > args: --classBased --log --test --typescript 1`] = `
+"[log] import Component from '@glimmer/component';
+
+export interface FooSignature {
+  Args: {};
+  Blocks: {
+    default: [];
+  };
+  Element: null;
+}
+
+export default class Foo extends Component<FooSignature> {
+  <template>
+    {{yield}}
+  </template>
+}
+
+[log] import { render } from '@ember/test-helpers';
+import { module, test } from 'qunit';
+import Foo from 'v1-app/components/foo';
+import { setupRenderingTest } from 'ember-qunit';
+
+module('Integration | Component | Foo', function (hooks) {
+  setupRenderingTest(hooks);
+
+  test('it renders', async function (assert) {
+    await render(<template><Foo /></template>);
+
+    assert.dom().hasText('');
+
+    await render(
+      <template>
+        <Foo>
+          template block text
+        </Foo>
+      </template>
+    );
+
+    assert.dom().hasText('template block text');
+  });
+});
+"
+`;
+
+exports[`package-type: v1-app > generator: component > args: --classBased --log --test 1`] = `
+"[log] import Component from '@glimmer/component';
+
+export default class Foo extends Component {
+  <template>{{yield}}</template>
+}
+
+[log] import { render } from '@ember/test-helpers';
+import { module, test } from 'qunit';
+import Foo from 'v1-app/components/foo';
+import { setupRenderingTest } from 'ember-qunit';
+
+module('Integration | Component | Foo', function (hooks) {
+  setupRenderingTest(hooks);
+
+  test('it renders', async function (assert) {
+    await render(<template><Foo /></template>);
+
+    assert.dom().hasText('');
+
+    await render(
+      <template>
+        <Foo>
+          template block text
+        </Foo>
+      </template>
+    );
+
+    assert.dom().hasText('template block text');
+  });
+});
+"
+`;
+
+exports[`package-type: v1-app > generator: component > args: --classBased --log --typescript 1`] = `
+"[log] import Component from '@glimmer/component';
+
+export interface FooSignature {
+  Args: {};
+  Blocks: {
+    default: [];
+  };
+  Element: null;
+}
+
+export default class Foo extends Component<FooSignature> {
+  <template>
+    {{yield}}
+  </template>
+}
+"
+`;
+
+exports[`package-type: v1-app > generator: component > args: --classBased --log 1`] = `
+"[log] import Component from '@glimmer/component';
+
+export default class Foo extends Component {
+  <template>{{yield}}</template>
+}
+"
+`;
+
+exports[`package-type: v1-app > generator: component > args: --classBased --namedExport --nested --test --typescript 1`] = `
+"[success] Generated component \`foo\` at \`app/components/foo/index.gts\`.
+[success] Generated component-test \`foo\` at \`tests/integration/components/foo-test.gts\`."
+`;
+
+exports[`package-type: v1-app > generator: component > args: --classBased --namedExport --nested --test 1`] = `
+"[success] Generated component \`foo\` at \`app/components/foo/index.gjs\`.
+[success] Generated component-test \`foo\` at \`tests/integration/components/foo-test.gjs\`."
+`;
+
+exports[`package-type: v1-app > generator: component > args: --classBased --namedExport --nested --typescript 1`] = `"[success] Generated component \`foo\` at \`app/components/foo/index.gts\`."`;
+
+exports[`package-type: v1-app > generator: component > args: --classBased --namedExport --nested 1`] = `"[success] Generated component \`foo\` at \`app/components/foo/index.gjs\`."`;
+
+exports[`package-type: v1-app > generator: component > args: --classBased --namedExport --test --typescript 1`] = `
+"[success] Generated component \`foo\` at \`app/components/foo.gts\`.
+[success] Generated component-test \`foo\` at \`tests/integration/components/foo-test.gts\`."
+`;
+
+exports[`package-type: v1-app > generator: component > args: --classBased --namedExport --test 1`] = `
+"[success] Generated component \`foo\` at \`app/components/foo.gjs\`.
+[success] Generated component-test \`foo\` at \`tests/integration/components/foo-test.gjs\`."
+`;
+
+exports[`package-type: v1-app > generator: component > args: --classBased --namedExport --typescript 1`] = `"[success] Generated component \`foo\` at \`app/components/foo.gts\`."`;
+
+exports[`package-type: v1-app > generator: component > args: --classBased --namedExport 1`] = `"[success] Generated component \`foo\` at \`app/components/foo.gjs\`."`;
+
+exports[`package-type: v1-app > generator: component > args: --classBased --nested --test --typescript 1`] = `
+"[success] Generated component \`foo\` at \`app/components/foo/index.gts\`.
+[success] Generated component-test \`foo\` at \`tests/integration/components/foo-test.gts\`."
+`;
+
+exports[`package-type: v1-app > generator: component > args: --classBased --nested --test 1`] = `
+"[success] Generated component \`foo\` at \`app/components/foo/index.gjs\`.
+[success] Generated component-test \`foo\` at \`tests/integration/components/foo-test.gjs\`."
+`;
+
+exports[`package-type: v1-app > generator: component > args: --classBased --nested --typescript 1`] = `"[success] Generated component \`foo\` at \`app/components/foo/index.gts\`."`;
+
+exports[`package-type: v1-app > generator: component > args: --classBased --nested 1`] = `"[success] Generated component \`foo\` at \`app/components/foo/index.gjs\`."`;
+
+exports[`package-type: v1-app > generator: component > args: --classBased --test --typescript 1`] = `
+"[success] Generated component \`foo\` at \`app/components/foo.gts\`.
+[success] Generated component-test \`foo\` at \`tests/integration/components/foo-test.gts\`."
+`;
+
+exports[`package-type: v1-app > generator: component > args: --classBased --test 1`] = `
+"[success] Generated component \`foo\` at \`app/components/foo.gjs\`.
+[success] Generated component-test \`foo\` at \`tests/integration/components/foo-test.gjs\`."
+`;
+
+exports[`package-type: v1-app > generator: component > args: --classBased --typescript 1`] = `"[success] Generated component \`foo\` at \`app/components/foo.gts\`."`;
+
+exports[`package-type: v1-app > generator: component > args: --classBased 1`] = `"[success] Generated component \`foo\` at \`app/components/foo.gjs\`."`;
+
+exports[`package-type: v1-app > generator: component > args: --log --namedExport --nested --test --typescript 1`] = `
+"[log] import type { TOC } from '@ember/component/template-only';
+
+export interface FooSignature {
+  Args: {};
+  Blocks: {
+    default: [];
+  };
+  Element: null;
+}
+
+export const Foo: TOC<FooSignature> = <template>{{yield}}</template>;
+
+[log] import { render } from '@ember/test-helpers';
+import { module, test } from 'qunit';
+import Foo from 'v1-app/components/foo';
+import { setupRenderingTest } from 'ember-qunit';
+
+module('Integration | Component | Foo', function (hooks) {
+  setupRenderingTest(hooks);
+
+  test('it renders', async function (assert) {
+    await render(<template><Foo /></template>);
+
+    assert.dom().hasText('');
+
+    await render(
+      <template>
+        <Foo>
+          template block text
+        </Foo>
+      </template>
+    );
+
+    assert.dom().hasText('template block text');
+  });
+});
+"
+`;
+
+exports[`package-type: v1-app > generator: component > args: --log --namedExport --nested --test 1`] = `
+"[log] <template>{{yield}}</template>
+
+[log] import { render } from '@ember/test-helpers';
+import { module, test } from 'qunit';
+import Foo from 'v1-app/components/foo';
+import { setupRenderingTest } from 'ember-qunit';
+
+module('Integration | Component | Foo', function (hooks) {
+  setupRenderingTest(hooks);
+
+  test('it renders', async function (assert) {
+    await render(<template><Foo /></template>);
+
+    assert.dom().hasText('');
+
+    await render(
+      <template>
+        <Foo>
+          template block text
+        </Foo>
+      </template>
+    );
+
+    assert.dom().hasText('template block text');
+  });
+});
+"
+`;
+
+exports[`package-type: v1-app > generator: component > args: --log --namedExport --nested --typescript 1`] = `
+"[log] import type { TOC } from '@ember/component/template-only';
+
+export interface FooSignature {
+  Args: {};
+  Blocks: {
+    default: [];
+  };
+  Element: null;
+}
+
+export const Foo: TOC<FooSignature> = <template>{{yield}}</template>;
+"
+`;
+
+exports[`package-type: v1-app > generator: component > args: --log --namedExport --nested 1`] = `
+"[log] <template>{{yield}}</template>
+"
+`;
+
+exports[`package-type: v1-app > generator: component > args: --log --namedExport --test --typescript 1`] = `
+"[log] import type { TOC } from '@ember/component/template-only';
+
+export interface FooSignature {
+  Args: {};
+  Blocks: {
+    default: [];
+  };
+  Element: null;
+}
+
+export const Foo: TOC<FooSignature> = <template>{{yield}}</template>;
+
+[log] import { render } from '@ember/test-helpers';
+import { module, test } from 'qunit';
+import Foo from 'v1-app/components/foo';
+import { setupRenderingTest } from 'ember-qunit';
+
+module('Integration | Component | Foo', function (hooks) {
+  setupRenderingTest(hooks);
+
+  test('it renders', async function (assert) {
+    await render(<template><Foo /></template>);
+
+    assert.dom().hasText('');
+
+    await render(
+      <template>
+        <Foo>
+          template block text
+        </Foo>
+      </template>
+    );
+
+    assert.dom().hasText('template block text');
+  });
+});
+"
+`;
+
+exports[`package-type: v1-app > generator: component > args: --log --namedExport --test 1`] = `
+"[log] <template>{{yield}}</template>
+
+[log] import { render } from '@ember/test-helpers';
+import { module, test } from 'qunit';
+import Foo from 'v1-app/components/foo';
+import { setupRenderingTest } from 'ember-qunit';
+
+module('Integration | Component | Foo', function (hooks) {
+  setupRenderingTest(hooks);
+
+  test('it renders', async function (assert) {
+    await render(<template><Foo /></template>);
+
+    assert.dom().hasText('');
+
+    await render(
+      <template>
+        <Foo>
+          template block text
+        </Foo>
+      </template>
+    );
+
+    assert.dom().hasText('template block text');
+  });
+});
+"
+`;
+
+exports[`package-type: v1-app > generator: component > args: --log --namedExport --typescript 1`] = `
+"[log] import type { TOC } from '@ember/component/template-only';
+
+export interface FooSignature {
+  Args: {};
+  Blocks: {
+    default: [];
+  };
+  Element: null;
+}
+
+export const Foo: TOC<FooSignature> = <template>{{yield}}</template>;
+"
+`;
+
+exports[`package-type: v1-app > generator: component > args: --log --namedExport 1`] = `
+"[log] <template>{{yield}}</template>
+"
+`;
+
+exports[`package-type: v1-app > generator: component > args: --log --nested --test --typescript 1`] = `
+"[log] import type { TOC } from '@ember/component/template-only';
+
+export interface FooSignature {
+  Args: {};
+  Blocks: {
+    default: [];
+  };
+  Element: null;
+}
+
+const Foo: TOC<FooSignature> = <template>{{yield}}</template>;
+
+export default Foo;
+
+[log] import { render } from '@ember/test-helpers';
+import { module, test } from 'qunit';
+import Foo from 'v1-app/components/foo';
+import { setupRenderingTest } from 'ember-qunit';
+
+module('Integration | Component | Foo', function (hooks) {
+  setupRenderingTest(hooks);
+
+  test('it renders', async function (assert) {
+    await render(<template><Foo /></template>);
+
+    assert.dom().hasText('');
+
+    await render(
+      <template>
+        <Foo>
+          template block text
+        </Foo>
+      </template>
+    );
+
+    assert.dom().hasText('template block text');
+  });
+});
+"
+`;
+
+exports[`package-type: v1-app > generator: component > args: --log --nested --test 1`] = `
+"[log] <template>{{yield}}</template>
+
+[log] import { render } from '@ember/test-helpers';
+import { module, test } from 'qunit';
+import Foo from 'v1-app/components/foo';
+import { setupRenderingTest } from 'ember-qunit';
+
+module('Integration | Component | Foo', function (hooks) {
+  setupRenderingTest(hooks);
+
+  test('it renders', async function (assert) {
+    await render(<template><Foo /></template>);
+
+    assert.dom().hasText('');
+
+    await render(
+      <template>
+        <Foo>
+          template block text
+        </Foo>
+      </template>
+    );
+
+    assert.dom().hasText('template block text');
+  });
+});
+"
+`;
+
+exports[`package-type: v1-app > generator: component > args: --log --nested --typescript 1`] = `
+"[log] import type { TOC } from '@ember/component/template-only';
+
+export interface FooSignature {
+  Args: {};
+  Blocks: {
+    default: [];
+  };
+  Element: null;
+}
+
+const Foo: TOC<FooSignature> = <template>{{yield}}</template>;
+
+export default Foo;
+"
+`;
+
+exports[`package-type: v1-app > generator: component > args: --log --nested 1`] = `
+"[log] <template>{{yield}}</template>
+"
+`;
+
+exports[`package-type: v1-app > generator: component > args: --log --test --typescript 1`] = `
+"[log] import type { TOC } from '@ember/component/template-only';
+
+export interface FooSignature {
+  Args: {};
+  Blocks: {
+    default: [];
+  };
+  Element: null;
+}
+
+const Foo: TOC<FooSignature> = <template>{{yield}}</template>;
+
+export default Foo;
+
+[log] import { render } from '@ember/test-helpers';
+import { module, test } from 'qunit';
+import Foo from 'v1-app/components/foo';
+import { setupRenderingTest } from 'ember-qunit';
+
+module('Integration | Component | Foo', function (hooks) {
+  setupRenderingTest(hooks);
+
+  test('it renders', async function (assert) {
+    await render(<template><Foo /></template>);
+
+    assert.dom().hasText('');
+
+    await render(
+      <template>
+        <Foo>
+          template block text
+        </Foo>
+      </template>
+    );
+
+    assert.dom().hasText('template block text');
+  });
+});
+"
+`;
+
+exports[`package-type: v1-app > generator: component > args: --log --test 1`] = `
+"[log] <template>{{yield}}</template>
+
+[log] import { render } from '@ember/test-helpers';
+import { module, test } from 'qunit';
+import Foo from 'v1-app/components/foo';
+import { setupRenderingTest } from 'ember-qunit';
+
+module('Integration | Component | Foo', function (hooks) {
+  setupRenderingTest(hooks);
+
+  test('it renders', async function (assert) {
+    await render(<template><Foo /></template>);
+
+    assert.dom().hasText('');
+
+    await render(
+      <template>
+        <Foo>
+          template block text
+        </Foo>
+      </template>
+    );
+
+    assert.dom().hasText('template block text');
+  });
+});
+"
+`;
+
+exports[`package-type: v1-app > generator: component > args: --log --typescript 1`] = `
+"[log] import type { TOC } from '@ember/component/template-only';
+
+export interface FooSignature {
+  Args: {};
+  Blocks: {
+    default: [];
+  };
+  Element: null;
+}
+
+const Foo: TOC<FooSignature> = <template>{{yield}}</template>;
+
+export default Foo;
+"
+`;
+
+exports[`package-type: v1-app > generator: component > args: --log 1`] = `
+"[log] <template>{{yield}}</template>
+"
+`;
+
+exports[`package-type: v1-app > generator: component > args: --namedExport --nested --test --typescript 1`] = `
+"[success] Generated component \`foo\` at \`app/components/foo/index.gts\`.
+[success] Generated component-test \`foo\` at \`tests/integration/components/foo-test.gts\`."
+`;
+
+exports[`package-type: v1-app > generator: component > args: --namedExport --nested --test 1`] = `
+"[success] Generated component \`foo\` at \`app/components/foo/index.gjs\`.
+[success] Generated component-test \`foo\` at \`tests/integration/components/foo-test.gjs\`."
+`;
+
+exports[`package-type: v1-app > generator: component > args: --namedExport --nested --typescript 1`] = `"[success] Generated component \`foo\` at \`app/components/foo/index.gts\`."`;
+
+exports[`package-type: v1-app > generator: component > args: --namedExport --nested 1`] = `"[success] Generated component \`foo\` at \`app/components/foo/index.gjs\`."`;
+
+exports[`package-type: v1-app > generator: component > args: --namedExport --test --typescript 1`] = `
+"[success] Generated component \`foo\` at \`app/components/foo.gts\`.
+[success] Generated component-test \`foo\` at \`tests/integration/components/foo-test.gts\`."
+`;
+
+exports[`package-type: v1-app > generator: component > args: --namedExport --test 1`] = `
+"[success] Generated component \`foo\` at \`app/components/foo.gjs\`.
+[success] Generated component-test \`foo\` at \`tests/integration/components/foo-test.gjs\`."
+`;
+
+exports[`package-type: v1-app > generator: component > args: --namedExport --typescript 1`] = `"[success] Generated component \`foo\` at \`app/components/foo.gts\`."`;
+
+exports[`package-type: v1-app > generator: component > args: --namedExport 1`] = `"[success] Generated component \`foo\` at \`app/components/foo.gjs\`."`;
+
+exports[`package-type: v1-app > generator: component > args: --nested --test --typescript 1`] = `
+"[success] Generated component \`foo\` at \`app/components/foo/index.gts\`.
+[success] Generated component-test \`foo\` at \`tests/integration/components/foo-test.gts\`."
+`;
+
+exports[`package-type: v1-app > generator: component > args: --nested --test 1`] = `
+"[success] Generated component \`foo\` at \`app/components/foo/index.gjs\`.
+[success] Generated component-test \`foo\` at \`tests/integration/components/foo-test.gjs\`."
+`;
+
+exports[`package-type: v1-app > generator: component > args: --nested --typescript 1`] = `"[success] Generated component \`foo\` at \`app/components/foo/index.gts\`."`;
+
+exports[`package-type: v1-app > generator: component > args: --nested 1`] = `"[success] Generated component \`foo\` at \`app/components/foo/index.gjs\`."`;
+
+exports[`package-type: v1-app > generator: component > args: --test --typescript 1`] = `
+"[success] Generated component \`foo\` at \`app/components/foo.gts\`.
+[success] Generated component-test \`foo\` at \`tests/integration/components/foo-test.gts\`."
+`;
+
+exports[`package-type: v1-app > generator: component > args: --test 1`] = `
+"[success] Generated component \`foo\` at \`app/components/foo.gjs\`.
+[success] Generated component-test \`foo\` at \`tests/integration/components/foo-test.gjs\`."
+`;
+
+exports[`package-type: v1-app > generator: component > args: --typescript 1`] = `"[success] Generated component \`foo\` at \`app/components/foo.gts\`."`;
+
+exports[`package-type: v1-app > generator: component-test > args: --log --typescript 1`] = `
+"[log] import { render } from '@ember/test-helpers';
+import { module, test } from 'qunit';
+import Foo from 'v1-app/components/foo';
+import { setupRenderingTest } from 'ember-qunit';
+
+module('Integration | Component | Foo', function (hooks) {
+  setupRenderingTest(hooks);
+
+  test('it renders', async function (assert) {
+    await render(<template><Foo /></template>);
+
+    assert.dom().hasText('');
+
+    await render(
+      <template>
+        <Foo>
+          template block text
+        </Foo>
+      </template>
+    );
+
+    assert.dom().hasText('template block text');
+  });
+});
+"
+`;
+
+exports[`package-type: v1-app > generator: component-test > args: --log 1`] = `
+"[log] import { render } from '@ember/test-helpers';
+import { module, test } from 'qunit';
+import Foo from 'v1-app/components/foo';
+import { setupRenderingTest } from 'ember-qunit';
+
+module('Integration | Component | Foo', function (hooks) {
+  setupRenderingTest(hooks);
+
+  test('it renders', async function (assert) {
+    await render(<template><Foo /></template>);
+
+    assert.dom().hasText('');
+
+    await render(
+      <template>
+        <Foo>
+          template block text
+        </Foo>
+      </template>
+    );
+
+    assert.dom().hasText('template block text');
+  });
+});
+"
+`;
+
+exports[`package-type: v1-app > generator: component-test > args: --typescript 1`] = `"[success] Generated component-test \`foo\` at \`tests/integration/components/foo-test.gts\`."`;
+
+exports[`package-type: v1-app > generator: controller > args: --log --test --typescript 1`] = `
+"[log] import Controller from '@ember/controller';
+
+export default class FooController extends Controller {}
+
+[log] import { module, test } from 'qunit';
+import { setupTest } from 'ember-qunit';
+
+module('Unit | Controller | Foo', function (hooks) {
+  setupTest(hooks);
+
+  test('it exists', function (assert) {
+    const controller = this.owner.lookup('controller:foo');
+
+    assert.ok(controller);
+  });
+});
+"
+`;
+
+exports[`package-type: v1-app > generator: controller > args: --log --test 1`] = `
+"[log] import Controller from '@ember/controller';
+
+export default class FooController extends Controller {}
+
+[log] import { module, test } from 'qunit';
+import { setupTest } from 'ember-qunit';
+
+module('Unit | Controller | Foo', function (hooks) {
+  setupTest(hooks);
+
+  test('it exists', function (assert) {
+    const controller = this.owner.lookup('controller:foo');
+
+    assert.ok(controller);
+  });
+});
+"
+`;
+
+exports[`package-type: v1-app > generator: controller > args: --log --typescript 1`] = `
+"[log] import Controller from '@ember/controller';
+
+export default class FooController extends Controller {}
+"
+`;
+
+exports[`package-type: v1-app > generator: controller > args: --log 1`] = `
+"[log] import Controller from '@ember/controller';
+
+export default class FooController extends Controller {}
+"
+`;
+
+exports[`package-type: v1-app > generator: controller > args: --test --typescript 1`] = `
+"[success] Generated controller \`foo\` at \`app/controllers/foo.ts\`.
+[success] Generated controller-test \`foo\` at \`tests/unit/controllers/foo-test.ts\`."
+`;
+
+exports[`package-type: v1-app > generator: controller > args: --test 1`] = `
+"[success] Generated controller \`foo\` at \`app/controllers/foo.js\`.
+[success] Generated controller-test \`foo\` at \`tests/unit/controllers/foo-test.js\`."
+`;
+
+exports[`package-type: v1-app > generator: controller > args: --typescript 1`] = `"[success] Generated controller \`foo\` at \`app/controllers/foo.ts\`."`;
+
+exports[`package-type: v1-app > generator: controller-test > args: --log --typescript 1`] = `
+"[log] import { module, test } from 'qunit';
+import { setupTest } from 'ember-qunit';
+
+module('Unit | Controller | Foo', function (hooks) {
+  setupTest(hooks);
+
+  test('it exists', function (assert) {
+    const controller = this.owner.lookup('controller:foo');
+
+    assert.ok(controller);
+  });
+});
+"
+`;
+
+exports[`package-type: v1-app > generator: controller-test > args: --log 1`] = `
+"[log] import { module, test } from 'qunit';
+import { setupTest } from 'ember-qunit';
+
+module('Unit | Controller | Foo', function (hooks) {
+  setupTest(hooks);
+
+  test('it exists', function (assert) {
+    const controller = this.owner.lookup('controller:foo');
+
+    assert.ok(controller);
+  });
+});
+"
+`;
+
+exports[`package-type: v1-app > generator: controller-test > args: --typescript 1`] = `"[success] Generated controller-test \`foo\` at \`tests/unit/controllers/foo-test.ts\`."`;
+
+exports[`package-type: v1-app > generator: helper > args: --classBased --log --namedExport --test --typescript 1`] = `
+"[log] import Helper from '@ember/component/helper';
+
+type Named = {};
+type Positional = [];
+type Return = Positional;
+
+export interface FooSignature {
+  Args: {
+    Named: Named;
+    Positional: Positional;
+  };
+  Return: Return;
+}
+
+export class foo extends Helper<FooSignature> {
+  compute(positional: Positional, named: Named): Return {
+    return positional;
+  }
+}
+
+[log] import { render } from '@ember/test-helpers';
+import { module, test } from 'qunit';
+import foo from 'v1-app/helpers/foo';
+import { setupRenderingTest } from 'ember-qunit';
+
+module('Integration | Helper | foo', function (hooks) {
+  setupRenderingTest(hooks);
+
+  test('it renders', async function (assert) {
+    const inputValue = '1234';
+
+    await render(<template>{{foo inputValue}}</template>);
+
+    assert.dom().hasText('1234');
+  });
+});
+"
+`;
+
+exports[`package-type: v1-app > generator: helper > args: --classBased --log --namedExport --test 1`] = `
+"[log] import Helper from '@ember/component/helper';
+
+export class foo extends Helper {
+  compute(positional, named) {
+    return positional;
+  }
+}
+
+[log] import { render } from '@ember/test-helpers';
+import { module, test } from 'qunit';
+import foo from 'v1-app/helpers/foo';
+import { setupRenderingTest } from 'ember-qunit';
+
+module('Integration | Helper | foo', function (hooks) {
+  setupRenderingTest(hooks);
+
+  test('it renders', async function (assert) {
+    const inputValue = '1234';
+
+    await render(<template>{{foo inputValue}}</template>);
+
+    assert.dom().hasText('1234');
+  });
+});
+"
+`;
+
+exports[`package-type: v1-app > generator: helper > args: --classBased --log --namedExport --typescript 1`] = `
+"[log] import Helper from '@ember/component/helper';
+
+type Named = {};
+type Positional = [];
+type Return = Positional;
+
+export interface FooSignature {
+  Args: {
+    Named: Named;
+    Positional: Positional;
+  };
+  Return: Return;
+}
+
+export class foo extends Helper<FooSignature> {
+  compute(positional: Positional, named: Named): Return {
+    return positional;
+  }
+}
+"
+`;
+
+exports[`package-type: v1-app > generator: helper > args: --classBased --log --namedExport 1`] = `
+"[log] import Helper from '@ember/component/helper';
+
+export class foo extends Helper {
+  compute(positional, named) {
+    return positional;
+  }
+}
+"
+`;
+
+exports[`package-type: v1-app > generator: helper > args: --classBased --log --test --typescript 1`] = `
+"[log] import Helper from '@ember/component/helper';
+
+type Named = {};
+type Positional = [];
+type Return = Positional;
+
+export interface FooSignature {
+  Args: {
+    Named: Named;
+    Positional: Positional;
+  };
+  Return: Return;
+}
+
+export default class foo extends Helper<FooSignature> {
+  compute(positional: Positional, named: Named): Return {
+    return positional;
+  }
+}
+
+[log] import { render } from '@ember/test-helpers';
+import { module, test } from 'qunit';
+import foo from 'v1-app/helpers/foo';
+import { setupRenderingTest } from 'ember-qunit';
+
+module('Integration | Helper | foo', function (hooks) {
+  setupRenderingTest(hooks);
+
+  test('it renders', async function (assert) {
+    const inputValue = '1234';
+
+    await render(<template>{{foo inputValue}}</template>);
+
+    assert.dom().hasText('1234');
+  });
+});
+"
+`;
+
+exports[`package-type: v1-app > generator: helper > args: --classBased --log --test 1`] = `
+"[log] import Helper from '@ember/component/helper';
+
+export default class foo extends Helper {
+  compute(positional, named) {
+    return positional;
+  }
+}
+
+[log] import { render } from '@ember/test-helpers';
+import { module, test } from 'qunit';
+import foo from 'v1-app/helpers/foo';
+import { setupRenderingTest } from 'ember-qunit';
+
+module('Integration | Helper | foo', function (hooks) {
+  setupRenderingTest(hooks);
+
+  test('it renders', async function (assert) {
+    const inputValue = '1234';
+
+    await render(<template>{{foo inputValue}}</template>);
+
+    assert.dom().hasText('1234');
+  });
+});
+"
+`;
+
+exports[`package-type: v1-app > generator: helper > args: --classBased --log --typescript 1`] = `
+"[log] import Helper from '@ember/component/helper';
+
+type Named = {};
+type Positional = [];
+type Return = Positional;
+
+export interface FooSignature {
+  Args: {
+    Named: Named;
+    Positional: Positional;
+  };
+  Return: Return;
+}
+
+export default class foo extends Helper<FooSignature> {
+  compute(positional: Positional, named: Named): Return {
+    return positional;
+  }
+}
+"
+`;
+
+exports[`package-type: v1-app > generator: helper > args: --classBased --log 1`] = `
+"[log] import Helper from '@ember/component/helper';
+
+export default class foo extends Helper {
+  compute(positional, named) {
+    return positional;
+  }
+}
+"
+`;
+
+exports[`package-type: v1-app > generator: helper > args: --classBased --namedExport --test --typescript 1`] = `
+"[success] Generated helper \`foo\` at \`app/helpers/foo.ts\`.
+[success] Generated helper-test \`foo\` at \`tests/integration/helpers/foo-test.gts\`."
+`;
+
+exports[`package-type: v1-app > generator: helper > args: --classBased --namedExport --test 1`] = `
+"[success] Generated helper \`foo\` at \`app/helpers/foo.js\`.
+[success] Generated helper-test \`foo\` at \`tests/integration/helpers/foo-test.gjs\`."
+`;
+
+exports[`package-type: v1-app > generator: helper > args: --classBased --namedExport --typescript 1`] = `"[success] Generated helper \`foo\` at \`app/helpers/foo.ts\`."`;
+
+exports[`package-type: v1-app > generator: helper > args: --classBased --namedExport 1`] = `"[success] Generated helper \`foo\` at \`app/helpers/foo.js\`."`;
+
+exports[`package-type: v1-app > generator: helper > args: --classBased --test --typescript 1`] = `
+"[success] Generated helper \`foo\` at \`app/helpers/foo.ts\`.
+[success] Generated helper-test \`foo\` at \`tests/integration/helpers/foo-test.gts\`."
+`;
+
+exports[`package-type: v1-app > generator: helper > args: --classBased --test 1`] = `
+"[success] Generated helper \`foo\` at \`app/helpers/foo.js\`.
+[success] Generated helper-test \`foo\` at \`tests/integration/helpers/foo-test.gjs\`."
+`;
+
+exports[`package-type: v1-app > generator: helper > args: --classBased --typescript 1`] = `"[success] Generated helper \`foo\` at \`app/helpers/foo.ts\`."`;
+
+exports[`package-type: v1-app > generator: helper > args: --classBased 1`] = `"[success] Generated helper \`foo\` at \`app/helpers/foo.js\`."`;
+
+exports[`package-type: v1-app > generator: helper > args: --log --namedExport --test --typescript 1`] = `
+"[log] export function foo(positional, named) {
+  return positional;
+}
+
+[log] import { render } from '@ember/test-helpers';
+import { module, test } from 'qunit';
+import foo from 'v1-app/helpers/foo';
+import { setupRenderingTest } from 'ember-qunit';
+
+module('Integration | Helper | foo', function (hooks) {
+  setupRenderingTest(hooks);
+
+  test('it renders', async function (assert) {
+    const inputValue = '1234';
+
+    await render(<template>{{foo inputValue}}</template>);
+
+    assert.dom().hasText('1234');
+  });
+});
+"
+`;
+
+exports[`package-type: v1-app > generator: helper > args: --log --namedExport --test 1`] = `
+"[log] export function foo(positional, named) {
+  return positional;
+}
+
+[log] import { render } from '@ember/test-helpers';
+import { module, test } from 'qunit';
+import foo from 'v1-app/helpers/foo';
+import { setupRenderingTest } from 'ember-qunit';
+
+module('Integration | Helper | foo', function (hooks) {
+  setupRenderingTest(hooks);
+
+  test('it renders', async function (assert) {
+    const inputValue = '1234';
+
+    await render(<template>{{foo inputValue}}</template>);
+
+    assert.dom().hasText('1234');
+  });
+});
+"
+`;
+
+exports[`package-type: v1-app > generator: helper > args: --log --namedExport --typescript 1`] = `
+"[log] export function foo(positional, named) {
+  return positional;
+}
+"
+`;
+
+exports[`package-type: v1-app > generator: helper > args: --log --namedExport 1`] = `
+"[log] export function foo(positional, named) {
+  return positional;
+}
+"
+`;
+
+exports[`package-type: v1-app > generator: helper > args: --log --test --typescript 1`] = `
+"[log] export default function foo(positional, named) {
+  return positional;
+}
+
+[log] import { render } from '@ember/test-helpers';
+import { module, test } from 'qunit';
+import foo from 'v1-app/helpers/foo';
+import { setupRenderingTest } from 'ember-qunit';
+
+module('Integration | Helper | foo', function (hooks) {
+  setupRenderingTest(hooks);
+
+  test('it renders', async function (assert) {
+    const inputValue = '1234';
+
+    await render(<template>{{foo inputValue}}</template>);
+
+    assert.dom().hasText('1234');
+  });
+});
+"
+`;
+
+exports[`package-type: v1-app > generator: helper > args: --log --test 1`] = `
+"[log] export default function foo(positional, named) {
+  return positional;
+}
+
+[log] import { render } from '@ember/test-helpers';
+import { module, test } from 'qunit';
+import foo from 'v1-app/helpers/foo';
+import { setupRenderingTest } from 'ember-qunit';
+
+module('Integration | Helper | foo', function (hooks) {
+  setupRenderingTest(hooks);
+
+  test('it renders', async function (assert) {
+    const inputValue = '1234';
+
+    await render(<template>{{foo inputValue}}</template>);
+
+    assert.dom().hasText('1234');
+  });
+});
+"
+`;
+
+exports[`package-type: v1-app > generator: helper > args: --log --typescript 1`] = `
+"[log] export default function foo(positional, named) {
+  return positional;
+}
+"
+`;
+
+exports[`package-type: v1-app > generator: helper > args: --log 1`] = `
+"[log] export default function foo(positional, named) {
+  return positional;
+}
+"
+`;
+
+exports[`package-type: v1-app > generator: helper > args: --namedExport --test --typescript 1`] = `
+"[success] Generated helper \`foo\` at \`app/helpers/foo.ts\`.
+[success] Generated helper-test \`foo\` at \`tests/integration/helpers/foo-test.gts\`."
+`;
+
+exports[`package-type: v1-app > generator: helper > args: --namedExport --test 1`] = `
+"[success] Generated helper \`foo\` at \`app/helpers/foo.js\`.
+[success] Generated helper-test \`foo\` at \`tests/integration/helpers/foo-test.gjs\`."
+`;
+
+exports[`package-type: v1-app > generator: helper > args: --namedExport --typescript 1`] = `"[success] Generated helper \`foo\` at \`app/helpers/foo.ts\`."`;
+
+exports[`package-type: v1-app > generator: helper > args: --namedExport 1`] = `"[success] Generated helper \`foo\` at \`app/helpers/foo.js\`."`;
+
+exports[`package-type: v1-app > generator: helper > args: --test --typescript 1`] = `
+"[success] Generated helper \`foo\` at \`app/helpers/foo.ts\`.
+[success] Generated helper-test \`foo\` at \`tests/integration/helpers/foo-test.gts\`."
+`;
+
+exports[`package-type: v1-app > generator: helper > args: --test 1`] = `
+"[success] Generated helper \`foo\` at \`app/helpers/foo.js\`.
+[success] Generated helper-test \`foo\` at \`tests/integration/helpers/foo-test.gjs\`."
+`;
+
+exports[`package-type: v1-app > generator: helper > args: --typescript 1`] = `"[success] Generated helper \`foo\` at \`app/helpers/foo.ts\`."`;
+
+exports[`package-type: v1-app > generator: helper-test > args: --log --typescript 1`] = `
+"[log] import { render } from '@ember/test-helpers';
+import { module, test } from 'qunit';
+import foo from 'v1-app/helpers/foo';
+import { setupRenderingTest } from 'ember-qunit';
+
+module('Integration | Helper | foo', function (hooks) {
+  setupRenderingTest(hooks);
+
+  test('it renders', async function (assert) {
+    const inputValue = '1234';
+
+    await render(<template>{{foo inputValue}}</template>);
+
+    assert.dom().hasText('1234');
+  });
+});
+"
+`;
+
+exports[`package-type: v1-app > generator: helper-test > args: --log 1`] = `
+"[log] import { render } from '@ember/test-helpers';
+import { module, test } from 'qunit';
+import foo from 'v1-app/helpers/foo';
+import { setupRenderingTest } from 'ember-qunit';
+
+module('Integration | Helper | foo', function (hooks) {
+  setupRenderingTest(hooks);
+
+  test('it renders', async function (assert) {
+    const inputValue = '1234';
+
+    await render(<template>{{foo inputValue}}</template>);
+
+    assert.dom().hasText('1234');
+  });
+});
+"
+`;
+
+exports[`package-type: v1-app > generator: helper-test > args: --typescript 1`] = `"[success] Generated helper-test \`foo\` at \`tests/integration/helpers/foo-test.gts\`."`;
+
+exports[`package-type: v1-app > generator: modifier > args: --classBased --log --namedExport --test --typescript 1`] = `
+"[log] import Modifier from 'ember-modifier';
+
+type Named = {};
+type Positional = [];
+type Element = null;
+
+export interface FooSignature {
+  Args: {
+    Named: Named;
+    Positional: Positional;
+  };
+  Element: Element;
+}
+
+export class foo extends Modifier<FooSignature> {
+  modify(element: Element, positional: Positional, named: Named) {}
+}
+
+[log] import { render } from '@ember/test-helpers';
+import { module, test } from 'qunit';
+import foo from 'v1-app/modifiers/foo';
+import { setupRenderingTest } from 'ember-qunit';
+
+module('Integration | Modifier | foo', function (hooks) {
+  setupRenderingTest(hooks);
+
+  test('it renders', async function (assert) {
+    await render(
+      <template>
+        <div {{foo}}></div>
+      </template>
+    );
+
+    assert.ok(true);
+  });
+});
+"
+`;
+
+exports[`package-type: v1-app > generator: modifier > args: --classBased --log --namedExport --test 1`] = `
+"[log] import Modifier from 'ember-modifier';
+
+export class foo extends Modifier {
+  modify(element, positional, named) {}
+}
+
+[log] import { render } from '@ember/test-helpers';
+import { module, test } from 'qunit';
+import foo from 'v1-app/modifiers/foo';
+import { setupRenderingTest } from 'ember-qunit';
+
+module('Integration | Modifier | foo', function (hooks) {
+  setupRenderingTest(hooks);
+
+  test('it renders', async function (assert) {
+    await render(
+      <template>
+        <div {{foo}}></div>
+      </template>
+    );
+
+    assert.ok(true);
+  });
+});
+"
+`;
+
+exports[`package-type: v1-app > generator: modifier > args: --classBased --log --namedExport --typescript 1`] = `
+"[log] import Modifier from 'ember-modifier';
+
+type Named = {};
+type Positional = [];
+type Element = null;
+
+export interface FooSignature {
+  Args: {
+    Named: Named;
+    Positional: Positional;
+  };
+  Element: Element;
+}
+
+export class foo extends Modifier<FooSignature> {
+  modify(element: Element, positional: Positional, named: Named) {}
+}
+"
+`;
+
+exports[`package-type: v1-app > generator: modifier > args: --classBased --log --namedExport 1`] = `
+"[log] import Modifier from 'ember-modifier';
+
+export class foo extends Modifier {
+  modify(element, positional, named) {}
+}
+"
+`;
+
+exports[`package-type: v1-app > generator: modifier > args: --classBased --log --test --typescript 1`] = `
+"[log] import Modifier from 'ember-modifier';
+
+type Named = {};
+type Positional = [];
+type Element = null;
+
+export interface FooSignature {
+  Args: {
+    Named: Named;
+    Positional: Positional;
+  };
+  Element: Element;
+}
+
+export default class foo extends Modifier<FooSignature> {
+  modify(element: Element, positional: Positional, named: Named) {}
+}
+
+[log] import { render } from '@ember/test-helpers';
+import { module, test } from 'qunit';
+import foo from 'v1-app/modifiers/foo';
+import { setupRenderingTest } from 'ember-qunit';
+
+module('Integration | Modifier | foo', function (hooks) {
+  setupRenderingTest(hooks);
+
+  test('it renders', async function (assert) {
+    await render(
+      <template>
+        <div {{foo}}></div>
+      </template>
+    );
+
+    assert.ok(true);
+  });
+});
+"
+`;
+
+exports[`package-type: v1-app > generator: modifier > args: --classBased --log --test 1`] = `
+"[log] import Modifier from 'ember-modifier';
+
+export default class foo extends Modifier {
+  modify(element, positional, named) {}
+}
+
+[log] import { render } from '@ember/test-helpers';
+import { module, test } from 'qunit';
+import foo from 'v1-app/modifiers/foo';
+import { setupRenderingTest } from 'ember-qunit';
+
+module('Integration | Modifier | foo', function (hooks) {
+  setupRenderingTest(hooks);
+
+  test('it renders', async function (assert) {
+    await render(
+      <template>
+        <div {{foo}}></div>
+      </template>
+    );
+
+    assert.ok(true);
+  });
+});
+"
+`;
+
+exports[`package-type: v1-app > generator: modifier > args: --classBased --log --typescript 1`] = `
+"[log] import Modifier from 'ember-modifier';
+
+type Named = {};
+type Positional = [];
+type Element = null;
+
+export interface FooSignature {
+  Args: {
+    Named: Named;
+    Positional: Positional;
+  };
+  Element: Element;
+}
+
+export default class foo extends Modifier<FooSignature> {
+  modify(element: Element, positional: Positional, named: Named) {}
+}
+"
+`;
+
+exports[`package-type: v1-app > generator: modifier > args: --classBased --log 1`] = `
+"[log] import Modifier from 'ember-modifier';
+
+export default class foo extends Modifier {
+  modify(element, positional, named) {}
+}
+"
+`;
+
+exports[`package-type: v1-app > generator: modifier > args: --classBased --namedExport --test --typescript 1`] = `
+"[success] Generated modifier \`foo\` at \`app/modifiers/foo.ts\`.
+[success] Generated modifier-test \`foo\` at \`tests/integration/modifiers/foo-test.gts\`."
+`;
+
+exports[`package-type: v1-app > generator: modifier > args: --classBased --namedExport --test 1`] = `
+"[success] Generated modifier \`foo\` at \`app/modifiers/foo.js\`.
+[success] Generated modifier-test \`foo\` at \`tests/integration/modifiers/foo-test.gjs\`."
+`;
+
+exports[`package-type: v1-app > generator: modifier > args: --classBased --namedExport --typescript 1`] = `"[success] Generated modifier \`foo\` at \`app/modifiers/foo.ts\`."`;
+
+exports[`package-type: v1-app > generator: modifier > args: --classBased --namedExport 1`] = `"[success] Generated modifier \`foo\` at \`app/modifiers/foo.js\`."`;
+
+exports[`package-type: v1-app > generator: modifier > args: --classBased --test --typescript 1`] = `
+"[success] Generated modifier \`foo\` at \`app/modifiers/foo.ts\`.
+[success] Generated modifier-test \`foo\` at \`tests/integration/modifiers/foo-test.gts\`."
+`;
+
+exports[`package-type: v1-app > generator: modifier > args: --classBased --test 1`] = `
+"[success] Generated modifier \`foo\` at \`app/modifiers/foo.js\`.
+[success] Generated modifier-test \`foo\` at \`tests/integration/modifiers/foo-test.gjs\`."
+`;
+
+exports[`package-type: v1-app > generator: modifier > args: --classBased --typescript 1`] = `"[success] Generated modifier \`foo\` at \`app/modifiers/foo.ts\`."`;
+
+exports[`package-type: v1-app > generator: modifier > args: --classBased 1`] = `"[success] Generated modifier \`foo\` at \`app/modifiers/foo.js\`."`;
+
+exports[`package-type: v1-app > generator: modifier > args: --log --namedExport --test --typescript 1`] = `
+"[log] import { modifier } from 'ember-modifier';
+
+export interface FooSignature {
+  Args: {
+    Named: {};
+    Positional: [];
+  };
+  Element: null;
+}
+
+export const foo = modifier<FooSignature>(function foo(element, positional, named) {});
+
+[log] import { render } from '@ember/test-helpers';
+import { module, test } from 'qunit';
+import foo from 'v1-app/modifiers/foo';
+import { setupRenderingTest } from 'ember-qunit';
+
+module('Integration | Modifier | foo', function (hooks) {
+  setupRenderingTest(hooks);
+
+  test('it renders', async function (assert) {
+    await render(
+      <template>
+        <div {{foo}}></div>
+      </template>
+    );
+
+    assert.ok(true);
+  });
+});
+"
+`;
+
+exports[`package-type: v1-app > generator: modifier > args: --log --namedExport --test 1`] = `
+"[log] import { modifier } from 'ember-modifier';
+
+export const foo = modifier(function foo(element, positional, named) {});
+
+[log] import { render } from '@ember/test-helpers';
+import { module, test } from 'qunit';
+import foo from 'v1-app/modifiers/foo';
+import { setupRenderingTest } from 'ember-qunit';
+
+module('Integration | Modifier | foo', function (hooks) {
+  setupRenderingTest(hooks);
+
+  test('it renders', async function (assert) {
+    await render(
+      <template>
+        <div {{foo}}></div>
+      </template>
+    );
+
+    assert.ok(true);
+  });
+});
+"
+`;
+
+exports[`package-type: v1-app > generator: modifier > args: --log --namedExport --typescript 1`] = `
+"[log] import { modifier } from 'ember-modifier';
+
+export interface FooSignature {
+  Args: {
+    Named: {};
+    Positional: [];
+  };
+  Element: null;
+}
+
+export const foo = modifier<FooSignature>(function foo(element, positional, named) {});
+"
+`;
+
+exports[`package-type: v1-app > generator: modifier > args: --log --namedExport 1`] = `
+"[log] import { modifier } from 'ember-modifier';
+
+export const foo = modifier(function foo(element, positional, named) {});
+"
+`;
+
+exports[`package-type: v1-app > generator: modifier > args: --log --test --typescript 1`] = `
+"[log] import { modifier } from 'ember-modifier';
+
+export interface FooSignature {
+  Args: {
+    Named: {};
+    Positional: [];
+  };
+  Element: null;
+}
+
+export default modifier<FooSignature>(function foo(element, positional, named) {});
+
+[log] import { render } from '@ember/test-helpers';
+import { module, test } from 'qunit';
+import foo from 'v1-app/modifiers/foo';
+import { setupRenderingTest } from 'ember-qunit';
+
+module('Integration | Modifier | foo', function (hooks) {
+  setupRenderingTest(hooks);
+
+  test('it renders', async function (assert) {
+    await render(
+      <template>
+        <div {{foo}}></div>
+      </template>
+    );
+
+    assert.ok(true);
+  });
+});
+"
+`;
+
+exports[`package-type: v1-app > generator: modifier > args: --log --test 1`] = `
+"[log] import { modifier } from 'ember-modifier';
+
+export default modifier(function foo(element, positional, named) {});
+
+[log] import { render } from '@ember/test-helpers';
+import { module, test } from 'qunit';
+import foo from 'v1-app/modifiers/foo';
+import { setupRenderingTest } from 'ember-qunit';
+
+module('Integration | Modifier | foo', function (hooks) {
+  setupRenderingTest(hooks);
+
+  test('it renders', async function (assert) {
+    await render(
+      <template>
+        <div {{foo}}></div>
+      </template>
+    );
+
+    assert.ok(true);
+  });
+});
+"
+`;
+
+exports[`package-type: v1-app > generator: modifier > args: --log --typescript 1`] = `
+"[log] import { modifier } from 'ember-modifier';
+
+export interface FooSignature {
+  Args: {
+    Named: {};
+    Positional: [];
+  };
+  Element: null;
+}
+
+export default modifier<FooSignature>(function foo(element, positional, named) {});
+"
+`;
+
+exports[`package-type: v1-app > generator: modifier > args: --log 1`] = `
+"[log] import { modifier } from 'ember-modifier';
+
+export default modifier(function foo(element, positional, named) {});
+"
+`;
+
+exports[`package-type: v1-app > generator: modifier > args: --namedExport --test --typescript 1`] = `
+"[success] Generated modifier \`foo\` at \`app/modifiers/foo.ts\`.
+[success] Generated modifier-test \`foo\` at \`tests/integration/modifiers/foo-test.gts\`."
+`;
+
+exports[`package-type: v1-app > generator: modifier > args: --namedExport --test 1`] = `
+"[success] Generated modifier \`foo\` at \`app/modifiers/foo.js\`.
+[success] Generated modifier-test \`foo\` at \`tests/integration/modifiers/foo-test.gjs\`."
+`;
+
+exports[`package-type: v1-app > generator: modifier > args: --namedExport --typescript 1`] = `"[success] Generated modifier \`foo\` at \`app/modifiers/foo.ts\`."`;
+
+exports[`package-type: v1-app > generator: modifier > args: --namedExport 1`] = `"[success] Generated modifier \`foo\` at \`app/modifiers/foo.js\`."`;
+
+exports[`package-type: v1-app > generator: modifier > args: --test --typescript 1`] = `
+"[success] Generated modifier \`foo\` at \`app/modifiers/foo.ts\`.
+[success] Generated modifier-test \`foo\` at \`tests/integration/modifiers/foo-test.gts\`."
+`;
+
+exports[`package-type: v1-app > generator: modifier > args: --test 1`] = `
+"[success] Generated modifier \`foo\` at \`app/modifiers/foo.js\`.
+[success] Generated modifier-test \`foo\` at \`tests/integration/modifiers/foo-test.gjs\`."
+`;
+
+exports[`package-type: v1-app > generator: modifier > args: --typescript 1`] = `"[success] Generated modifier \`foo\` at \`app/modifiers/foo.ts\`."`;
+
+exports[`package-type: v1-app > generator: modifier-test > args: --log --typescript 1`] = `
+"[log] import { render } from '@ember/test-helpers';
+import { module, test } from 'qunit';
+import foo from 'v1-app/modifiers/foo';
+import { setupRenderingTest } from 'ember-qunit';
+
+module('Integration | Modifier | foo', function (hooks) {
+  setupRenderingTest(hooks);
+
+  test('it renders', async function (assert) {
+    await render(
+      <template>
+        <div {{foo}}></div>
+      </template>
+    );
+
+    assert.ok(true);
+  });
+});
+"
+`;
+
+exports[`package-type: v1-app > generator: modifier-test > args: --log 1`] = `
+"[log] import { render } from '@ember/test-helpers';
+import { module, test } from 'qunit';
+import foo from 'v1-app/modifiers/foo';
+import { setupRenderingTest } from 'ember-qunit';
+
+module('Integration | Modifier | foo', function (hooks) {
+  setupRenderingTest(hooks);
+
+  test('it renders', async function (assert) {
+    await render(
+      <template>
+        <div {{foo}}></div>
+      </template>
+    );
+
+    assert.ok(true);
+  });
+});
+"
+`;
+
+exports[`package-type: v1-app > generator: modifier-test > args: --typescript 1`] = `"[success] Generated modifier-test \`foo\` at \`tests/integration/modifiers/foo-test.gts\`."`;
+
+exports[`package-type: v1-app > generator: route > args: --log --test --typescript 1`] = `
+"[log] import Route from '@ember/routing/route';
+
+export default class FooRoute extends Route {}
+
+[log] import { module, test } from 'qunit';
+import { setupTest } from 'ember-qunit';
+
+module('Unit | Route | Foo', function (hooks) {
+  setupTest(hooks);
+
+  test('it exists', function (assert) {
+    const route = this.owner.lookup('route:foo');
+
+    assert.ok(route);
+  });
+});
+"
+`;
+
+exports[`package-type: v1-app > generator: route > args: --log --test 1`] = `
+"[log] import Route from '@ember/routing/route';
+
+export default class FooRoute extends Route {}
+
+[log] import { module, test } from 'qunit';
+import { setupTest } from 'ember-qunit';
+
+module('Unit | Route | Foo', function (hooks) {
+  setupTest(hooks);
+
+  test('it exists', function (assert) {
+    const route = this.owner.lookup('route:foo');
+
+    assert.ok(route);
+  });
+});
+"
+`;
+
+exports[`package-type: v1-app > generator: route > args: --log --typescript 1`] = `
+"[log] import Route from '@ember/routing/route';
+
+export default class FooRoute extends Route {}
+"
+`;
+
+exports[`package-type: v1-app > generator: route > args: --log 1`] = `
+"[log] import Route from '@ember/routing/route';
+
+export default class FooRoute extends Route {}
+"
+`;
+
+exports[`package-type: v1-app > generator: route > args: --test --typescript 1`] = `
+"[success] Generated route \`foo\` at \`app/routes/foo.ts\`.
+[success] Generated route-test \`foo\` at \`tests/unit/routes/foo-test.ts\`."
+`;
+
+exports[`package-type: v1-app > generator: route > args: --test 1`] = `
+"[success] Generated route \`foo\` at \`app/routes/foo.js\`.
+[success] Generated route-test \`foo\` at \`tests/unit/routes/foo-test.js\`."
+`;
+
+exports[`package-type: v1-app > generator: route > args: --typescript 1`] = `"[success] Generated route \`foo\` at \`app/routes/foo.ts\`."`;
+
+exports[`package-type: v1-app > generator: route-test > args: --log --typescript 1`] = `
+"[log] import { module, test } from 'qunit';
+import { setupTest } from 'ember-qunit';
+
+module('Unit | Route | Foo', function (hooks) {
+  setupTest(hooks);
+
+  test('it exists', function (assert) {
+    const route = this.owner.lookup('route:foo');
+
+    assert.ok(route);
+  });
+});
+"
+`;
+
+exports[`package-type: v1-app > generator: route-test > args: --log 1`] = `
+"[log] import { module, test } from 'qunit';
+import { setupTest } from 'ember-qunit';
+
+module('Unit | Route | Foo', function (hooks) {
+  setupTest(hooks);
+
+  test('it exists', function (assert) {
+    const route = this.owner.lookup('route:foo');
+
+    assert.ok(route);
+  });
+});
+"
+`;
+
+exports[`package-type: v1-app > generator: route-test > args: --typescript 1`] = `"[success] Generated route-test \`foo\` at \`tests/unit/routes/foo-test.ts\`."`;
+
+exports[`package-type: v1-app > generator: service > args: --log --test --typescript 1`] = `
+"[log] import Service from '@ember/service';
+
+export default class FooService extends Service {}
+
+declare module '@ember/service' {
+  interface Registry {
+    foo: FooService;
+  }
+}
+
+[log] import { module, test } from 'qunit';
+import { setupTest } from 'ember-qunit';
+
+module('Unit | Service | Foo', function (hooks) {
+  setupTest(hooks);
+
+  test('it exists', function (assert) {
+    const service = this.owner.lookup('service:foo');
+
+    assert.ok(service);
+  });
+});
+"
+`;
+
+exports[`package-type: v1-app > generator: service > args: --log --test 1`] = `
+"[log] import Service from '@ember/service';
+
+export default class FooService extends Service {}
+
+[log] import { module, test } from 'qunit';
+import { setupTest } from 'ember-qunit';
+
+module('Unit | Service | Foo', function (hooks) {
+  setupTest(hooks);
+
+  test('it exists', function (assert) {
+    const service = this.owner.lookup('service:foo');
+
+    assert.ok(service);
+  });
+});
+"
+`;
+
+exports[`package-type: v1-app > generator: service > args: --log --typescript 1`] = `
+"[log] import Service from '@ember/service';
+
+export default class FooService extends Service {}
+
+declare module '@ember/service' {
+  interface Registry {
+    foo: FooService;
+  }
+}
+"
+`;
+
+exports[`package-type: v1-app > generator: service > args: --log 1`] = `
+"[log] import Service from '@ember/service';
+
+export default class FooService extends Service {}
+"
+`;
+
+exports[`package-type: v1-app > generator: service > args: --test --typescript 1`] = `
+"[success] Generated service \`foo\` at \`app/services/foo.ts\`.
+[success] Generated service-test \`foo\` at \`tests/unit/services/foo-test.ts\`."
+`;
+
+exports[`package-type: v1-app > generator: service > args: --test 1`] = `
+"[success] Generated service \`foo\` at \`app/services/foo.js\`.
+[success] Generated service-test \`foo\` at \`tests/unit/services/foo-test.js\`."
+`;
+
+exports[`package-type: v1-app > generator: service > args: --typescript 1`] = `"[success] Generated service \`foo\` at \`app/services/foo.ts\`."`;
+
+exports[`package-type: v1-app > generator: service-test > args: --log --typescript 1`] = `
+"[log] import { module, test } from 'qunit';
+import { setupTest } from 'ember-qunit';
+
+module('Unit | Service | Foo', function (hooks) {
+  setupTest(hooks);
+
+  test('it exists', function (assert) {
+    const service = this.owner.lookup('service:foo');
+
+    assert.ok(service);
+  });
+});
+"
+`;
+
+exports[`package-type: v1-app > generator: service-test > args: --log 1`] = `
+"[log] import { module, test } from 'qunit';
+import { setupTest } from 'ember-qunit';
+
+module('Unit | Service | Foo', function (hooks) {
+  setupTest(hooks);
+
+  test('it exists', function (assert) {
+    const service = this.owner.lookup('service:foo');
+
+    assert.ok(service);
+  });
+});
+"
+`;
+
+exports[`package-type: v1-app > generator: service-test > args: --typescript 1`] = `"[success] Generated service-test \`foo\` at \`tests/unit/services/foo-test.ts\`."`;
+
+exports[`package-type: v1-app > generator: util > args: --log --namedExport --test --typescript 1`] = `
+"[log] export function foo() {
+  return true;
+}
+
+[log] import foo from 'v1-app/utils/foo';
+import { module, test } from 'qunit';
+
+module('Unit | Util | foo', function () {
+  test('it works', function (assert) {
+    const result = foo();
+
+    assert.ok(result);
+  });
+});
+"
+`;
+
+exports[`package-type: v1-app > generator: util > args: --log --namedExport --test 1`] = `
+"[log] export function foo() {
+  return true;
+}
+
+[log] import foo from 'v1-app/utils/foo';
+import { module, test } from 'qunit';
+
+module('Unit | Util | foo', function () {
+  test('it works', function (assert) {
+    const result = foo();
+
+    assert.ok(result);
+  });
+});
+"
+`;
+
+exports[`package-type: v1-app > generator: util > args: --log --namedExport --typescript 1`] = `
+"[log] export function foo() {
+  return true;
+}
+"
+`;
+
+exports[`package-type: v1-app > generator: util > args: --log --namedExport 1`] = `
+"[log] export function foo() {
+  return true;
+}
+"
+`;
+
+exports[`package-type: v1-app > generator: util > args: --log --test --typescript 1`] = `
+"[log] export default function foo() {
+  return true;
+}
+
+[log] import foo from 'v1-app/utils/foo';
+import { module, test } from 'qunit';
+
+module('Unit | Util | foo', function () {
+  test('it works', function (assert) {
+    const result = foo();
+
+    assert.ok(result);
+  });
+});
+"
+`;
+
+exports[`package-type: v1-app > generator: util > args: --log --test 1`] = `
+"[log] export default function foo() {
+  return true;
+}
+
+[log] import foo from 'v1-app/utils/foo';
+import { module, test } from 'qunit';
+
+module('Unit | Util | foo', function () {
+  test('it works', function (assert) {
+    const result = foo();
+
+    assert.ok(result);
+  });
+});
+"
+`;
+
+exports[`package-type: v1-app > generator: util > args: --log --typescript 1`] = `
+"[log] export default function foo() {
+  return true;
+}
+"
+`;
+
+exports[`package-type: v1-app > generator: util > args: --log 1`] = `
+"[log] export default function foo() {
+  return true;
+}
+"
+`;
+
+exports[`package-type: v1-app > generator: util > args: --namedExport --test --typescript 1`] = `
+"[success] Generated util \`foo\` at \`app/utils/foo.ts\`.
+[success] Generated util-test \`foo\` at \`tests/unit/utils/foo-test.ts\`."
+`;
+
+exports[`package-type: v1-app > generator: util > args: --namedExport --test 1`] = `
+"[success] Generated util \`foo\` at \`app/utils/foo.js\`.
+[success] Generated util-test \`foo\` at \`tests/unit/utils/foo-test.js\`."
+`;
+
+exports[`package-type: v1-app > generator: util > args: --namedExport --typescript 1`] = `"[success] Generated util \`foo\` at \`app/utils/foo.ts\`."`;
+
+exports[`package-type: v1-app > generator: util > args: --namedExport 1`] = `"[success] Generated util \`foo\` at \`app/utils/foo.js\`."`;
+
+exports[`package-type: v1-app > generator: util > args: --test --typescript 1`] = `
+"[success] Generated util \`foo\` at \`app/utils/foo.ts\`.
+[success] Generated util-test \`foo\` at \`tests/unit/utils/foo-test.ts\`."
+`;
+
+exports[`package-type: v1-app > generator: util > args: --test 1`] = `
+"[success] Generated util \`foo\` at \`app/utils/foo.js\`.
+[success] Generated util-test \`foo\` at \`tests/unit/utils/foo-test.js\`."
+`;
+
+exports[`package-type: v1-app > generator: util > args: --typescript 1`] = `"[success] Generated util \`foo\` at \`app/utils/foo.ts\`."`;
+
+exports[`package-type: v1-app > generator: util-test > args: --log --typescript 1`] = `
+"[log] import foo from 'v1-app/utils/foo';
+import { module, test } from 'qunit';
+
+module('Unit | Util | foo', function () {
+  test('it works', function (assert) {
+    const result = foo();
+
+    assert.ok(result);
+  });
+});
+"
+`;
+
+exports[`package-type: v1-app > generator: util-test > args: --log 1`] = `
+"[log] import foo from 'v1-app/utils/foo';
+import { module, test } from 'qunit';
+
+module('Unit | Util | foo', function () {
+  test('it works', function (assert) {
+    const result = foo();
+
+    assert.ok(result);
+  });
+});
+"
+`;
+
+exports[`package-type: v1-app > generator: util-test > args: --typescript 1`] = `"[success] Generated util-test \`foo\` at \`tests/unit/utils/foo-test.ts\`."`;
+
+exports[`package-type: v2-addon > generator: acceptance-test > args: --log --typescript 1`] = `
+"[log] import { currentURL, visit } from '@ember/test-helpers';
+import { module, test } from 'qunit';
+import { setupApplicationTest } from 'v2-addon/tests/helpers';
+
+module('Acceptance | foo', function (hooks) {
+  setupApplicationTest(hooks);
+
+  test('it visits /foo', async function (assert) {
+    await visit('/foo');
+
+    assert.strictEqual(currentURL(), '/foo');
+  });
+});
+"
+`;
+
+exports[`package-type: v2-addon > generator: acceptance-test > args: --log 1`] = `
+"[log] import { currentURL, visit } from '@ember/test-helpers';
+import { module, test } from 'qunit';
+import { setupApplicationTest } from 'v2-addon/tests/helpers';
+
+module('Acceptance | foo', function (hooks) {
+  setupApplicationTest(hooks);
+
+  test('it visits /foo', async function (assert) {
+    await visit('/foo');
+
+    assert.strictEqual(currentURL(), '/foo');
+  });
+});
+"
+`;
+
+exports[`package-type: v2-addon > generator: acceptance-test > args: --typescript 1`] = `"[success] Generated acceptance-test \`foo\` at \`tests/acceptance/foo-test.ts\`."`;
+
+exports[`package-type: v2-addon > generator: component > args: --classBased --log --namedExport --nested --test --typescript 1`] = `
+"[log] import Component from '@glimmer/component';
+
+export interface FooSignature {
+  Args: {};
+  Blocks: {
+    default: [];
+  };
+  Element: null;
+}
+
+export class Foo extends Component<FooSignature> {
+  <template>
+    {{yield}}
+  </template>
+}
+
+[log] import { render } from '@ember/test-helpers';
+import { module, test } from 'qunit';
+import Foo from 'v2-addon/components/foo';
+import { setupRenderingTest } from 'v2-addon/tests/helpers';
+
+module('Integration | Component | Foo', function (hooks) {
+  setupRenderingTest(hooks);
+
+  test('it renders', async function (assert) {
+    await render(<template><Foo /></template>);
+
+    assert.dom().hasText('');
+
+    await render(
+      <template>
+        <Foo>
+          template block text
+        </Foo>
+      </template>
+    );
+
+    assert.dom().hasText('template block text');
+  });
+});
+"
+`;
+
+exports[`package-type: v2-addon > generator: component > args: --classBased --log --namedExport --nested --test 1`] = `
+"[log] import Component from '@glimmer/component';
+
+export class Foo extends Component {
+  <template>{{yield}}</template>
+}
+
+[log] import { render } from '@ember/test-helpers';
+import { module, test } from 'qunit';
+import Foo from 'v2-addon/components/foo';
+import { setupRenderingTest } from 'v2-addon/tests/helpers';
+
+module('Integration | Component | Foo', function (hooks) {
+  setupRenderingTest(hooks);
+
+  test('it renders', async function (assert) {
+    await render(<template><Foo /></template>);
+
+    assert.dom().hasText('');
+
+    await render(
+      <template>
+        <Foo>
+          template block text
+        </Foo>
+      </template>
+    );
+
+    assert.dom().hasText('template block text');
+  });
+});
+"
+`;
+
+exports[`package-type: v2-addon > generator: component > args: --classBased --log --namedExport --nested --typescript 1`] = `
+"[log] import Component from '@glimmer/component';
+
+export interface FooSignature {
+  Args: {};
+  Blocks: {
+    default: [];
+  };
+  Element: null;
+}
+
+export class Foo extends Component<FooSignature> {
+  <template>
+    {{yield}}
+  </template>
+}
+"
+`;
+
+exports[`package-type: v2-addon > generator: component > args: --classBased --log --namedExport --nested 1`] = `
+"[log] import Component from '@glimmer/component';
+
+export class Foo extends Component {
+  <template>{{yield}}</template>
+}
+"
+`;
+
+exports[`package-type: v2-addon > generator: component > args: --classBased --log --namedExport --test --typescript 1`] = `
+"[log] import Component from '@glimmer/component';
+
+export interface FooSignature {
+  Args: {};
+  Blocks: {
+    default: [];
+  };
+  Element: null;
+}
+
+export class Foo extends Component<FooSignature> {
+  <template>
+    {{yield}}
+  </template>
+}
+
+[log] import { render } from '@ember/test-helpers';
+import { module, test } from 'qunit';
+import Foo from 'v2-addon/components/foo';
+import { setupRenderingTest } from 'v2-addon/tests/helpers';
+
+module('Integration | Component | Foo', function (hooks) {
+  setupRenderingTest(hooks);
+
+  test('it renders', async function (assert) {
+    await render(<template><Foo /></template>);
+
+    assert.dom().hasText('');
+
+    await render(
+      <template>
+        <Foo>
+          template block text
+        </Foo>
+      </template>
+    );
+
+    assert.dom().hasText('template block text');
+  });
+});
+"
+`;
+
+exports[`package-type: v2-addon > generator: component > args: --classBased --log --namedExport --test 1`] = `
+"[log] import Component from '@glimmer/component';
+
+export class Foo extends Component {
+  <template>{{yield}}</template>
+}
+
+[log] import { render } from '@ember/test-helpers';
+import { module, test } from 'qunit';
+import Foo from 'v2-addon/components/foo';
+import { setupRenderingTest } from 'v2-addon/tests/helpers';
+
+module('Integration | Component | Foo', function (hooks) {
+  setupRenderingTest(hooks);
+
+  test('it renders', async function (assert) {
+    await render(<template><Foo /></template>);
+
+    assert.dom().hasText('');
+
+    await render(
+      <template>
+        <Foo>
+          template block text
+        </Foo>
+      </template>
+    );
+
+    assert.dom().hasText('template block text');
+  });
+});
+"
+`;
+
+exports[`package-type: v2-addon > generator: component > args: --classBased --log --namedExport --typescript 1`] = `
+"[log] import Component from '@glimmer/component';
+
+export interface FooSignature {
+  Args: {};
+  Blocks: {
+    default: [];
+  };
+  Element: null;
+}
+
+export class Foo extends Component<FooSignature> {
+  <template>
+    {{yield}}
+  </template>
+}
+"
+`;
+
+exports[`package-type: v2-addon > generator: component > args: --classBased --log --namedExport 1`] = `
+"[log] import Component from '@glimmer/component';
+
+export class Foo extends Component {
+  <template>{{yield}}</template>
+}
+"
+`;
+
+exports[`package-type: v2-addon > generator: component > args: --classBased --log --nested --test --typescript 1`] = `
+"[log] import Component from '@glimmer/component';
+
+export interface FooSignature {
+  Args: {};
+  Blocks: {
+    default: [];
+  };
+  Element: null;
+}
+
+export default class Foo extends Component<FooSignature> {
+  <template>
+    {{yield}}
+  </template>
+}
+
+[log] import { render } from '@ember/test-helpers';
+import { module, test } from 'qunit';
+import Foo from 'v2-addon/components/foo';
+import { setupRenderingTest } from 'v2-addon/tests/helpers';
+
+module('Integration | Component | Foo', function (hooks) {
+  setupRenderingTest(hooks);
+
+  test('it renders', async function (assert) {
+    await render(<template><Foo /></template>);
+
+    assert.dom().hasText('');
+
+    await render(
+      <template>
+        <Foo>
+          template block text
+        </Foo>
+      </template>
+    );
+
+    assert.dom().hasText('template block text');
+  });
+});
+"
+`;
+
+exports[`package-type: v2-addon > generator: component > args: --classBased --log --nested --test 1`] = `
+"[log] import Component from '@glimmer/component';
+
+export default class Foo extends Component {
+  <template>{{yield}}</template>
+}
+
+[log] import { render } from '@ember/test-helpers';
+import { module, test } from 'qunit';
+import Foo from 'v2-addon/components/foo';
+import { setupRenderingTest } from 'v2-addon/tests/helpers';
+
+module('Integration | Component | Foo', function (hooks) {
+  setupRenderingTest(hooks);
+
+  test('it renders', async function (assert) {
+    await render(<template><Foo /></template>);
+
+    assert.dom().hasText('');
+
+    await render(
+      <template>
+        <Foo>
+          template block text
+        </Foo>
+      </template>
+    );
+
+    assert.dom().hasText('template block text');
+  });
+});
+"
+`;
+
+exports[`package-type: v2-addon > generator: component > args: --classBased --log --nested --typescript 1`] = `
+"[log] import Component from '@glimmer/component';
+
+export interface FooSignature {
+  Args: {};
+  Blocks: {
+    default: [];
+  };
+  Element: null;
+}
+
+export default class Foo extends Component<FooSignature> {
+  <template>
+    {{yield}}
+  </template>
+}
+"
+`;
+
+exports[`package-type: v2-addon > generator: component > args: --classBased --log --nested 1`] = `
+"[log] import Component from '@glimmer/component';
+
+export default class Foo extends Component {
+  <template>{{yield}}</template>
+}
+"
+`;
+
+exports[`package-type: v2-addon > generator: component > args: --classBased --log --test --typescript 1`] = `
+"[log] import Component from '@glimmer/component';
+
+export interface FooSignature {
+  Args: {};
+  Blocks: {
+    default: [];
+  };
+  Element: null;
+}
+
+export default class Foo extends Component<FooSignature> {
+  <template>
+    {{yield}}
+  </template>
+}
+
+[log] import { render } from '@ember/test-helpers';
+import { module, test } from 'qunit';
+import Foo from 'v2-addon/components/foo';
+import { setupRenderingTest } from 'v2-addon/tests/helpers';
+
+module('Integration | Component | Foo', function (hooks) {
+  setupRenderingTest(hooks);
+
+  test('it renders', async function (assert) {
+    await render(<template><Foo /></template>);
+
+    assert.dom().hasText('');
+
+    await render(
+      <template>
+        <Foo>
+          template block text
+        </Foo>
+      </template>
+    );
+
+    assert.dom().hasText('template block text');
+  });
+});
+"
+`;
+
+exports[`package-type: v2-addon > generator: component > args: --classBased --log --test 1`] = `
+"[log] import Component from '@glimmer/component';
+
+export default class Foo extends Component {
+  <template>{{yield}}</template>
+}
+
+[log] import { render } from '@ember/test-helpers';
+import { module, test } from 'qunit';
+import Foo from 'v2-addon/components/foo';
+import { setupRenderingTest } from 'v2-addon/tests/helpers';
+
+module('Integration | Component | Foo', function (hooks) {
+  setupRenderingTest(hooks);
+
+  test('it renders', async function (assert) {
+    await render(<template><Foo /></template>);
+
+    assert.dom().hasText('');
+
+    await render(
+      <template>
+        <Foo>
+          template block text
+        </Foo>
+      </template>
+    );
+
+    assert.dom().hasText('template block text');
+  });
+});
+"
+`;
+
+exports[`package-type: v2-addon > generator: component > args: --classBased --log --typescript 1`] = `
+"[log] import Component from '@glimmer/component';
+
+export interface FooSignature {
+  Args: {};
+  Blocks: {
+    default: [];
+  };
+  Element: null;
+}
+
+export default class Foo extends Component<FooSignature> {
+  <template>
+    {{yield}}
+  </template>
+}
+"
+`;
+
+exports[`package-type: v2-addon > generator: component > args: --classBased --log 1`] = `
+"[log] import Component from '@glimmer/component';
+
+export default class Foo extends Component {
+  <template>{{yield}}</template>
+}
+"
+`;
+
+exports[`package-type: v2-addon > generator: component > args: --classBased --namedExport --nested --test --typescript 1`] = `
+"[success] Generated component \`foo\` at \`src/components/foo/index.gts\`.
+[success] Generated component-test \`foo\` at \`tests/integration/components/foo-test.gts\`."
+`;
+
+exports[`package-type: v2-addon > generator: component > args: --classBased --namedExport --nested --test 1`] = `
+"[success] Generated component \`foo\` at \`src/components/foo/index.gjs\`.
+[success] Generated component-test \`foo\` at \`tests/integration/components/foo-test.gjs\`."
+`;
+
+exports[`package-type: v2-addon > generator: component > args: --classBased --namedExport --nested --typescript 1`] = `"[success] Generated component \`foo\` at \`src/components/foo/index.gts\`."`;
+
+exports[`package-type: v2-addon > generator: component > args: --classBased --namedExport --nested 1`] = `"[success] Generated component \`foo\` at \`src/components/foo/index.gjs\`."`;
+
+exports[`package-type: v2-addon > generator: component > args: --classBased --namedExport --test --typescript 1`] = `
+"[success] Generated component \`foo\` at \`src/components/foo.gts\`.
+[success] Generated component-test \`foo\` at \`tests/integration/components/foo-test.gts\`."
+`;
+
+exports[`package-type: v2-addon > generator: component > args: --classBased --namedExport --test 1`] = `
+"[success] Generated component \`foo\` at \`src/components/foo.gjs\`.
+[success] Generated component-test \`foo\` at \`tests/integration/components/foo-test.gjs\`."
+`;
+
+exports[`package-type: v2-addon > generator: component > args: --classBased --namedExport --typescript 1`] = `"[success] Generated component \`foo\` at \`src/components/foo.gts\`."`;
+
+exports[`package-type: v2-addon > generator: component > args: --classBased --namedExport 1`] = `"[success] Generated component \`foo\` at \`src/components/foo.gjs\`."`;
+
+exports[`package-type: v2-addon > generator: component > args: --classBased --nested --test --typescript 1`] = `
+"[success] Generated component \`foo\` at \`src/components/foo/index.gts\`.
+[success] Generated component-test \`foo\` at \`tests/integration/components/foo-test.gts\`."
+`;
+
+exports[`package-type: v2-addon > generator: component > args: --classBased --nested --test 1`] = `
+"[success] Generated component \`foo\` at \`src/components/foo/index.gjs\`.
+[success] Generated component-test \`foo\` at \`tests/integration/components/foo-test.gjs\`."
+`;
+
+exports[`package-type: v2-addon > generator: component > args: --classBased --nested --typescript 1`] = `"[success] Generated component \`foo\` at \`src/components/foo/index.gts\`."`;
+
+exports[`package-type: v2-addon > generator: component > args: --classBased --nested 1`] = `"[success] Generated component \`foo\` at \`src/components/foo/index.gjs\`."`;
+
+exports[`package-type: v2-addon > generator: component > args: --classBased --test --typescript 1`] = `
+"[success] Generated component \`foo\` at \`src/components/foo.gts\`.
+[success] Generated component-test \`foo\` at \`tests/integration/components/foo-test.gts\`."
+`;
+
+exports[`package-type: v2-addon > generator: component > args: --classBased --test 1`] = `
+"[success] Generated component \`foo\` at \`src/components/foo.gjs\`.
+[success] Generated component-test \`foo\` at \`tests/integration/components/foo-test.gjs\`."
+`;
+
+exports[`package-type: v2-addon > generator: component > args: --classBased --typescript 1`] = `"[success] Generated component \`foo\` at \`src/components/foo.gts\`."`;
+
+exports[`package-type: v2-addon > generator: component > args: --classBased 1`] = `"[success] Generated component \`foo\` at \`src/components/foo.gjs\`."`;
+
+exports[`package-type: v2-addon > generator: component > args: --log --namedExport --nested --test --typescript 1`] = `
+"[log] import type { TOC } from '@ember/component/template-only';
+
+export interface FooSignature {
+  Args: {};
+  Blocks: {
+    default: [];
+  };
+  Element: null;
+}
+
+export const Foo: TOC<FooSignature> = <template>{{yield}}</template>;
+
+[log] import { render } from '@ember/test-helpers';
+import { module, test } from 'qunit';
+import Foo from 'v2-addon/components/foo';
+import { setupRenderingTest } from 'v2-addon/tests/helpers';
+
+module('Integration | Component | Foo', function (hooks) {
+  setupRenderingTest(hooks);
+
+  test('it renders', async function (assert) {
+    await render(<template><Foo /></template>);
+
+    assert.dom().hasText('');
+
+    await render(
+      <template>
+        <Foo>
+          template block text
+        </Foo>
+      </template>
+    );
+
+    assert.dom().hasText('template block text');
+  });
+});
+"
+`;
+
+exports[`package-type: v2-addon > generator: component > args: --log --namedExport --nested --test 1`] = `
+"[log] <template>{{yield}}</template>
+
+[log] import { render } from '@ember/test-helpers';
+import { module, test } from 'qunit';
+import Foo from 'v2-addon/components/foo';
+import { setupRenderingTest } from 'v2-addon/tests/helpers';
+
+module('Integration | Component | Foo', function (hooks) {
+  setupRenderingTest(hooks);
+
+  test('it renders', async function (assert) {
+    await render(<template><Foo /></template>);
+
+    assert.dom().hasText('');
+
+    await render(
+      <template>
+        <Foo>
+          template block text
+        </Foo>
+      </template>
+    );
+
+    assert.dom().hasText('template block text');
+  });
+});
+"
+`;
+
+exports[`package-type: v2-addon > generator: component > args: --log --namedExport --nested --typescript 1`] = `
+"[log] import type { TOC } from '@ember/component/template-only';
+
+export interface FooSignature {
+  Args: {};
+  Blocks: {
+    default: [];
+  };
+  Element: null;
+}
+
+export const Foo: TOC<FooSignature> = <template>{{yield}}</template>;
+"
+`;
+
+exports[`package-type: v2-addon > generator: component > args: --log --namedExport --nested 1`] = `
+"[log] <template>{{yield}}</template>
+"
+`;
+
+exports[`package-type: v2-addon > generator: component > args: --log --namedExport --test --typescript 1`] = `
+"[log] import type { TOC } from '@ember/component/template-only';
+
+export interface FooSignature {
+  Args: {};
+  Blocks: {
+    default: [];
+  };
+  Element: null;
+}
+
+export const Foo: TOC<FooSignature> = <template>{{yield}}</template>;
+
+[log] import { render } from '@ember/test-helpers';
+import { module, test } from 'qunit';
+import Foo from 'v2-addon/components/foo';
+import { setupRenderingTest } from 'v2-addon/tests/helpers';
+
+module('Integration | Component | Foo', function (hooks) {
+  setupRenderingTest(hooks);
+
+  test('it renders', async function (assert) {
+    await render(<template><Foo /></template>);
+
+    assert.dom().hasText('');
+
+    await render(
+      <template>
+        <Foo>
+          template block text
+        </Foo>
+      </template>
+    );
+
+    assert.dom().hasText('template block text');
+  });
+});
+"
+`;
+
+exports[`package-type: v2-addon > generator: component > args: --log --namedExport --test 1`] = `
+"[log] <template>{{yield}}</template>
+
+[log] import { render } from '@ember/test-helpers';
+import { module, test } from 'qunit';
+import Foo from 'v2-addon/components/foo';
+import { setupRenderingTest } from 'v2-addon/tests/helpers';
+
+module('Integration | Component | Foo', function (hooks) {
+  setupRenderingTest(hooks);
+
+  test('it renders', async function (assert) {
+    await render(<template><Foo /></template>);
+
+    assert.dom().hasText('');
+
+    await render(
+      <template>
+        <Foo>
+          template block text
+        </Foo>
+      </template>
+    );
+
+    assert.dom().hasText('template block text');
+  });
+});
+"
+`;
+
+exports[`package-type: v2-addon > generator: component > args: --log --namedExport --typescript 1`] = `
+"[log] import type { TOC } from '@ember/component/template-only';
+
+export interface FooSignature {
+  Args: {};
+  Blocks: {
+    default: [];
+  };
+  Element: null;
+}
+
+export const Foo: TOC<FooSignature> = <template>{{yield}}</template>;
+"
+`;
+
+exports[`package-type: v2-addon > generator: component > args: --log --namedExport 1`] = `
+"[log] <template>{{yield}}</template>
+"
+`;
+
+exports[`package-type: v2-addon > generator: component > args: --log --nested --test --typescript 1`] = `
+"[log] import type { TOC } from '@ember/component/template-only';
+
+export interface FooSignature {
+  Args: {};
+  Blocks: {
+    default: [];
+  };
+  Element: null;
+}
+
+const Foo: TOC<FooSignature> = <template>{{yield}}</template>;
+
+export default Foo;
+
+[log] import { render } from '@ember/test-helpers';
+import { module, test } from 'qunit';
+import Foo from 'v2-addon/components/foo';
+import { setupRenderingTest } from 'v2-addon/tests/helpers';
+
+module('Integration | Component | Foo', function (hooks) {
+  setupRenderingTest(hooks);
+
+  test('it renders', async function (assert) {
+    await render(<template><Foo /></template>);
+
+    assert.dom().hasText('');
+
+    await render(
+      <template>
+        <Foo>
+          template block text
+        </Foo>
+      </template>
+    );
+
+    assert.dom().hasText('template block text');
+  });
+});
+"
+`;
+
+exports[`package-type: v2-addon > generator: component > args: --log --nested --test 1`] = `
+"[log] <template>{{yield}}</template>
+
+[log] import { render } from '@ember/test-helpers';
+import { module, test } from 'qunit';
+import Foo from 'v2-addon/components/foo';
+import { setupRenderingTest } from 'v2-addon/tests/helpers';
+
+module('Integration | Component | Foo', function (hooks) {
+  setupRenderingTest(hooks);
+
+  test('it renders', async function (assert) {
+    await render(<template><Foo /></template>);
+
+    assert.dom().hasText('');
+
+    await render(
+      <template>
+        <Foo>
+          template block text
+        </Foo>
+      </template>
+    );
+
+    assert.dom().hasText('template block text');
+  });
+});
+"
+`;
+
+exports[`package-type: v2-addon > generator: component > args: --log --nested --typescript 1`] = `
+"[log] import type { TOC } from '@ember/component/template-only';
+
+export interface FooSignature {
+  Args: {};
+  Blocks: {
+    default: [];
+  };
+  Element: null;
+}
+
+const Foo: TOC<FooSignature> = <template>{{yield}}</template>;
+
+export default Foo;
+"
+`;
+
+exports[`package-type: v2-addon > generator: component > args: --log --nested 1`] = `
+"[log] <template>{{yield}}</template>
+"
+`;
+
+exports[`package-type: v2-addon > generator: component > args: --log --test --typescript 1`] = `
+"[log] import type { TOC } from '@ember/component/template-only';
+
+export interface FooSignature {
+  Args: {};
+  Blocks: {
+    default: [];
+  };
+  Element: null;
+}
+
+const Foo: TOC<FooSignature> = <template>{{yield}}</template>;
+
+export default Foo;
+
+[log] import { render } from '@ember/test-helpers';
+import { module, test } from 'qunit';
+import Foo from 'v2-addon/components/foo';
+import { setupRenderingTest } from 'v2-addon/tests/helpers';
+
+module('Integration | Component | Foo', function (hooks) {
+  setupRenderingTest(hooks);
+
+  test('it renders', async function (assert) {
+    await render(<template><Foo /></template>);
+
+    assert.dom().hasText('');
+
+    await render(
+      <template>
+        <Foo>
+          template block text
+        </Foo>
+      </template>
+    );
+
+    assert.dom().hasText('template block text');
+  });
+});
+"
+`;
+
+exports[`package-type: v2-addon > generator: component > args: --log --test 1`] = `
+"[log] <template>{{yield}}</template>
+
+[log] import { render } from '@ember/test-helpers';
+import { module, test } from 'qunit';
+import Foo from 'v2-addon/components/foo';
+import { setupRenderingTest } from 'v2-addon/tests/helpers';
+
+module('Integration | Component | Foo', function (hooks) {
+  setupRenderingTest(hooks);
+
+  test('it renders', async function (assert) {
+    await render(<template><Foo /></template>);
+
+    assert.dom().hasText('');
+
+    await render(
+      <template>
+        <Foo>
+          template block text
+        </Foo>
+      </template>
+    );
+
+    assert.dom().hasText('template block text');
+  });
+});
+"
+`;
+
+exports[`package-type: v2-addon > generator: component > args: --log --typescript 1`] = `
+"[log] import type { TOC } from '@ember/component/template-only';
+
+export interface FooSignature {
+  Args: {};
+  Blocks: {
+    default: [];
+  };
+  Element: null;
+}
+
+const Foo: TOC<FooSignature> = <template>{{yield}}</template>;
+
+export default Foo;
+"
+`;
+
+exports[`package-type: v2-addon > generator: component > args: --log 1`] = `
+"[log] <template>{{yield}}</template>
+"
+`;
+
+exports[`package-type: v2-addon > generator: component > args: --namedExport --nested --test --typescript 1`] = `
+"[success] Generated component \`foo\` at \`src/components/foo/index.gts\`.
+[success] Generated component-test \`foo\` at \`tests/integration/components/foo-test.gts\`."
+`;
+
+exports[`package-type: v2-addon > generator: component > args: --namedExport --nested --test 1`] = `
+"[success] Generated component \`foo\` at \`src/components/foo/index.gjs\`.
+[success] Generated component-test \`foo\` at \`tests/integration/components/foo-test.gjs\`."
+`;
+
+exports[`package-type: v2-addon > generator: component > args: --namedExport --nested --typescript 1`] = `"[success] Generated component \`foo\` at \`src/components/foo/index.gts\`."`;
+
+exports[`package-type: v2-addon > generator: component > args: --namedExport --nested 1`] = `"[success] Generated component \`foo\` at \`src/components/foo/index.gjs\`."`;
+
+exports[`package-type: v2-addon > generator: component > args: --namedExport --test --typescript 1`] = `
+"[success] Generated component \`foo\` at \`src/components/foo.gts\`.
+[success] Generated component-test \`foo\` at \`tests/integration/components/foo-test.gts\`."
+`;
+
+exports[`package-type: v2-addon > generator: component > args: --namedExport --test 1`] = `
+"[success] Generated component \`foo\` at \`src/components/foo.gjs\`.
+[success] Generated component-test \`foo\` at \`tests/integration/components/foo-test.gjs\`."
+`;
+
+exports[`package-type: v2-addon > generator: component > args: --namedExport --typescript 1`] = `"[success] Generated component \`foo\` at \`src/components/foo.gts\`."`;
+
+exports[`package-type: v2-addon > generator: component > args: --namedExport 1`] = `"[success] Generated component \`foo\` at \`src/components/foo.gjs\`."`;
+
+exports[`package-type: v2-addon > generator: component > args: --nested --test --typescript 1`] = `
+"[success] Generated component \`foo\` at \`src/components/foo/index.gts\`.
+[success] Generated component-test \`foo\` at \`tests/integration/components/foo-test.gts\`."
+`;
+
+exports[`package-type: v2-addon > generator: component > args: --nested --test 1`] = `
+"[success] Generated component \`foo\` at \`src/components/foo/index.gjs\`.
+[success] Generated component-test \`foo\` at \`tests/integration/components/foo-test.gjs\`."
+`;
+
+exports[`package-type: v2-addon > generator: component > args: --nested --typescript 1`] = `"[success] Generated component \`foo\` at \`src/components/foo/index.gts\`."`;
+
+exports[`package-type: v2-addon > generator: component > args: --nested 1`] = `"[success] Generated component \`foo\` at \`src/components/foo/index.gjs\`."`;
+
+exports[`package-type: v2-addon > generator: component > args: --test --typescript 1`] = `
+"[success] Generated component \`foo\` at \`src/components/foo.gts\`.
+[success] Generated component-test \`foo\` at \`tests/integration/components/foo-test.gts\`."
+`;
+
+exports[`package-type: v2-addon > generator: component > args: --test 1`] = `
+"[success] Generated component \`foo\` at \`src/components/foo.gjs\`.
+[success] Generated component-test \`foo\` at \`tests/integration/components/foo-test.gjs\`."
+`;
+
+exports[`package-type: v2-addon > generator: component > args: --typescript 1`] = `"[success] Generated component \`foo\` at \`src/components/foo.gts\`."`;
+
+exports[`package-type: v2-addon > generator: component-test > args: --log --typescript 1`] = `
+"[log] import { render } from '@ember/test-helpers';
+import { module, test } from 'qunit';
+import Foo from 'v2-addon/components/foo';
+import { setupRenderingTest } from 'v2-addon/tests/helpers';
+
+module('Integration | Component | Foo', function (hooks) {
+  setupRenderingTest(hooks);
+
+  test('it renders', async function (assert) {
+    await render(<template><Foo /></template>);
+
+    assert.dom().hasText('');
+
+    await render(
+      <template>
+        <Foo>
+          template block text
+        </Foo>
+      </template>
+    );
+
+    assert.dom().hasText('template block text');
+  });
+});
+"
+`;
+
+exports[`package-type: v2-addon > generator: component-test > args: --log 1`] = `
+"[log] import { render } from '@ember/test-helpers';
+import { module, test } from 'qunit';
+import Foo from 'v2-addon/components/foo';
+import { setupRenderingTest } from 'v2-addon/tests/helpers';
+
+module('Integration | Component | Foo', function (hooks) {
+  setupRenderingTest(hooks);
+
+  test('it renders', async function (assert) {
+    await render(<template><Foo /></template>);
+
+    assert.dom().hasText('');
+
+    await render(
+      <template>
+        <Foo>
+          template block text
+        </Foo>
+      </template>
+    );
+
+    assert.dom().hasText('template block text');
+  });
+});
+"
+`;
+
+exports[`package-type: v2-addon > generator: component-test > args: --typescript 1`] = `"[success] Generated component-test \`foo\` at \`tests/integration/components/foo-test.gts\`."`;
+
+exports[`package-type: v2-addon > generator: controller > args: --log --test --typescript 1`] = `
+"[log] import Controller from '@ember/controller';
+
+export default class FooController extends Controller {}
+
+[log] import { module, test } from 'qunit';
+import { setupTest } from 'v2-addon/tests/helpers';
+
+module('Unit | Controller | Foo', function (hooks) {
+  setupTest(hooks);
+
+  test('it exists', function (assert) {
+    const controller = this.owner.lookup('controller:foo');
+
+    assert.ok(controller);
+  });
+});
+"
+`;
+
+exports[`package-type: v2-addon > generator: controller > args: --log --test 1`] = `
+"[log] import Controller from '@ember/controller';
+
+export default class FooController extends Controller {}
+
+[log] import { module, test } from 'qunit';
+import { setupTest } from 'v2-addon/tests/helpers';
+
+module('Unit | Controller | Foo', function (hooks) {
+  setupTest(hooks);
+
+  test('it exists', function (assert) {
+    const controller = this.owner.lookup('controller:foo');
+
+    assert.ok(controller);
+  });
+});
+"
+`;
+
+exports[`package-type: v2-addon > generator: controller > args: --log --typescript 1`] = `
+"[log] import Controller from '@ember/controller';
+
+export default class FooController extends Controller {}
+"
+`;
+
+exports[`package-type: v2-addon > generator: controller > args: --log 1`] = `
+"[log] import Controller from '@ember/controller';
+
+export default class FooController extends Controller {}
+"
+`;
+
+exports[`package-type: v2-addon > generator: controller > args: --test --typescript 1`] = `
+"[success] Generated controller \`foo\` at \`src/controllers/foo.ts\`.
+[success] Generated controller-test \`foo\` at \`tests/unit/controllers/foo-test.ts\`."
+`;
+
+exports[`package-type: v2-addon > generator: controller > args: --test 1`] = `
+"[success] Generated controller \`foo\` at \`src/controllers/foo.js\`.
+[success] Generated controller-test \`foo\` at \`tests/unit/controllers/foo-test.js\`."
+`;
+
+exports[`package-type: v2-addon > generator: controller > args: --typescript 1`] = `"[success] Generated controller \`foo\` at \`src/controllers/foo.ts\`."`;
+
+exports[`package-type: v2-addon > generator: controller-test > args: --log --typescript 1`] = `
+"[log] import { module, test } from 'qunit';
+import { setupTest } from 'v2-addon/tests/helpers';
+
+module('Unit | Controller | Foo', function (hooks) {
+  setupTest(hooks);
+
+  test('it exists', function (assert) {
+    const controller = this.owner.lookup('controller:foo');
+
+    assert.ok(controller);
+  });
+});
+"
+`;
+
+exports[`package-type: v2-addon > generator: controller-test > args: --log 1`] = `
+"[log] import { module, test } from 'qunit';
+import { setupTest } from 'v2-addon/tests/helpers';
+
+module('Unit | Controller | Foo', function (hooks) {
+  setupTest(hooks);
+
+  test('it exists', function (assert) {
+    const controller = this.owner.lookup('controller:foo');
+
+    assert.ok(controller);
+  });
+});
+"
+`;
+
+exports[`package-type: v2-addon > generator: controller-test > args: --typescript 1`] = `"[success] Generated controller-test \`foo\` at \`tests/unit/controllers/foo-test.ts\`."`;
+
+exports[`package-type: v2-addon > generator: helper > args: --classBased --log --namedExport --test --typescript 1`] = `
+"[log] import Helper from '@ember/component/helper';
+
+type Named = {};
+type Positional = [];
+type Return = Positional;
+
+export interface FooSignature {
+  Args: {
+    Named: Named;
+    Positional: Positional;
+  };
+  Return: Return;
+}
+
+export class foo extends Helper<FooSignature> {
+  compute(positional: Positional, named: Named): Return {
+    return positional;
+  }
+}
+
+[log] import { render } from '@ember/test-helpers';
+import { module, test } from 'qunit';
+import foo from 'v2-addon/helpers/foo';
+import { setupRenderingTest } from 'v2-addon/tests/helpers';
+
+module('Integration | Helper | foo', function (hooks) {
+  setupRenderingTest(hooks);
+
+  test('it renders', async function (assert) {
+    const inputValue = '1234';
+
+    await render(<template>{{foo inputValue}}</template>);
+
+    assert.dom().hasText('1234');
+  });
+});
+"
+`;
+
+exports[`package-type: v2-addon > generator: helper > args: --classBased --log --namedExport --test 1`] = `
+"[log] import Helper from '@ember/component/helper';
+
+export class foo extends Helper {
+  compute(positional, named) {
+    return positional;
+  }
+}
+
+[log] import { render } from '@ember/test-helpers';
+import { module, test } from 'qunit';
+import foo from 'v2-addon/helpers/foo';
+import { setupRenderingTest } from 'v2-addon/tests/helpers';
+
+module('Integration | Helper | foo', function (hooks) {
+  setupRenderingTest(hooks);
+
+  test('it renders', async function (assert) {
+    const inputValue = '1234';
+
+    await render(<template>{{foo inputValue}}</template>);
+
+    assert.dom().hasText('1234');
+  });
+});
+"
+`;
+
+exports[`package-type: v2-addon > generator: helper > args: --classBased --log --namedExport --typescript 1`] = `
+"[log] import Helper from '@ember/component/helper';
+
+type Named = {};
+type Positional = [];
+type Return = Positional;
+
+export interface FooSignature {
+  Args: {
+    Named: Named;
+    Positional: Positional;
+  };
+  Return: Return;
+}
+
+export class foo extends Helper<FooSignature> {
+  compute(positional: Positional, named: Named): Return {
+    return positional;
+  }
+}
+"
+`;
+
+exports[`package-type: v2-addon > generator: helper > args: --classBased --log --namedExport 1`] = `
+"[log] import Helper from '@ember/component/helper';
+
+export class foo extends Helper {
+  compute(positional, named) {
+    return positional;
+  }
+}
+"
+`;
+
+exports[`package-type: v2-addon > generator: helper > args: --classBased --log --test --typescript 1`] = `
+"[log] import Helper from '@ember/component/helper';
+
+type Named = {};
+type Positional = [];
+type Return = Positional;
+
+export interface FooSignature {
+  Args: {
+    Named: Named;
+    Positional: Positional;
+  };
+  Return: Return;
+}
+
+export default class foo extends Helper<FooSignature> {
+  compute(positional: Positional, named: Named): Return {
+    return positional;
+  }
+}
+
+[log] import { render } from '@ember/test-helpers';
+import { module, test } from 'qunit';
+import foo from 'v2-addon/helpers/foo';
+import { setupRenderingTest } from 'v2-addon/tests/helpers';
+
+module('Integration | Helper | foo', function (hooks) {
+  setupRenderingTest(hooks);
+
+  test('it renders', async function (assert) {
+    const inputValue = '1234';
+
+    await render(<template>{{foo inputValue}}</template>);
+
+    assert.dom().hasText('1234');
+  });
+});
+"
+`;
+
+exports[`package-type: v2-addon > generator: helper > args: --classBased --log --test 1`] = `
+"[log] import Helper from '@ember/component/helper';
+
+export default class foo extends Helper {
+  compute(positional, named) {
+    return positional;
+  }
+}
+
+[log] import { render } from '@ember/test-helpers';
+import { module, test } from 'qunit';
+import foo from 'v2-addon/helpers/foo';
+import { setupRenderingTest } from 'v2-addon/tests/helpers';
+
+module('Integration | Helper | foo', function (hooks) {
+  setupRenderingTest(hooks);
+
+  test('it renders', async function (assert) {
+    const inputValue = '1234';
+
+    await render(<template>{{foo inputValue}}</template>);
+
+    assert.dom().hasText('1234');
+  });
+});
+"
+`;
+
+exports[`package-type: v2-addon > generator: helper > args: --classBased --log --typescript 1`] = `
+"[log] import Helper from '@ember/component/helper';
+
+type Named = {};
+type Positional = [];
+type Return = Positional;
+
+export interface FooSignature {
+  Args: {
+    Named: Named;
+    Positional: Positional;
+  };
+  Return: Return;
+}
+
+export default class foo extends Helper<FooSignature> {
+  compute(positional: Positional, named: Named): Return {
+    return positional;
+  }
+}
+"
+`;
+
+exports[`package-type: v2-addon > generator: helper > args: --classBased --log 1`] = `
+"[log] import Helper from '@ember/component/helper';
+
+export default class foo extends Helper {
+  compute(positional, named) {
+    return positional;
+  }
+}
+"
+`;
+
+exports[`package-type: v2-addon > generator: helper > args: --classBased --namedExport --test --typescript 1`] = `
+"[success] Generated helper \`foo\` at \`src/helpers/foo.ts\`.
+[success] Generated helper-test \`foo\` at \`tests/integration/helpers/foo-test.gts\`."
+`;
+
+exports[`package-type: v2-addon > generator: helper > args: --classBased --namedExport --test 1`] = `
+"[success] Generated helper \`foo\` at \`src/helpers/foo.js\`.
+[success] Generated helper-test \`foo\` at \`tests/integration/helpers/foo-test.gjs\`."
+`;
+
+exports[`package-type: v2-addon > generator: helper > args: --classBased --namedExport --typescript 1`] = `"[success] Generated helper \`foo\` at \`src/helpers/foo.ts\`."`;
+
+exports[`package-type: v2-addon > generator: helper > args: --classBased --namedExport 1`] = `"[success] Generated helper \`foo\` at \`src/helpers/foo.js\`."`;
+
+exports[`package-type: v2-addon > generator: helper > args: --classBased --test --typescript 1`] = `
+"[success] Generated helper \`foo\` at \`src/helpers/foo.ts\`.
+[success] Generated helper-test \`foo\` at \`tests/integration/helpers/foo-test.gts\`."
+`;
+
+exports[`package-type: v2-addon > generator: helper > args: --classBased --test 1`] = `
+"[success] Generated helper \`foo\` at \`src/helpers/foo.js\`.
+[success] Generated helper-test \`foo\` at \`tests/integration/helpers/foo-test.gjs\`."
+`;
+
+exports[`package-type: v2-addon > generator: helper > args: --classBased --typescript 1`] = `"[success] Generated helper \`foo\` at \`src/helpers/foo.ts\`."`;
+
+exports[`package-type: v2-addon > generator: helper > args: --classBased 1`] = `"[success] Generated helper \`foo\` at \`src/helpers/foo.js\`."`;
+
+exports[`package-type: v2-addon > generator: helper > args: --log --namedExport --test --typescript 1`] = `
+"[log] export function foo(positional, named) {
+  return positional;
+}
+
+[log] import { render } from '@ember/test-helpers';
+import { module, test } from 'qunit';
+import foo from 'v2-addon/helpers/foo';
+import { setupRenderingTest } from 'v2-addon/tests/helpers';
+
+module('Integration | Helper | foo', function (hooks) {
+  setupRenderingTest(hooks);
+
+  test('it renders', async function (assert) {
+    const inputValue = '1234';
+
+    await render(<template>{{foo inputValue}}</template>);
+
+    assert.dom().hasText('1234');
+  });
+});
+"
+`;
+
+exports[`package-type: v2-addon > generator: helper > args: --log --namedExport --test 1`] = `
+"[log] export function foo(positional, named) {
+  return positional;
+}
+
+[log] import { render } from '@ember/test-helpers';
+import { module, test } from 'qunit';
+import foo from 'v2-addon/helpers/foo';
+import { setupRenderingTest } from 'v2-addon/tests/helpers';
+
+module('Integration | Helper | foo', function (hooks) {
+  setupRenderingTest(hooks);
+
+  test('it renders', async function (assert) {
+    const inputValue = '1234';
+
+    await render(<template>{{foo inputValue}}</template>);
+
+    assert.dom().hasText('1234');
+  });
+});
+"
+`;
+
+exports[`package-type: v2-addon > generator: helper > args: --log --namedExport --typescript 1`] = `
+"[log] export function foo(positional, named) {
+  return positional;
+}
+"
+`;
+
+exports[`package-type: v2-addon > generator: helper > args: --log --namedExport 1`] = `
+"[log] export function foo(positional, named) {
+  return positional;
+}
+"
+`;
+
+exports[`package-type: v2-addon > generator: helper > args: --log --test --typescript 1`] = `
+"[log] export default function foo(positional, named) {
+  return positional;
+}
+
+[log] import { render } from '@ember/test-helpers';
+import { module, test } from 'qunit';
+import foo from 'v2-addon/helpers/foo';
+import { setupRenderingTest } from 'v2-addon/tests/helpers';
+
+module('Integration | Helper | foo', function (hooks) {
+  setupRenderingTest(hooks);
+
+  test('it renders', async function (assert) {
+    const inputValue = '1234';
+
+    await render(<template>{{foo inputValue}}</template>);
+
+    assert.dom().hasText('1234');
+  });
+});
+"
+`;
+
+exports[`package-type: v2-addon > generator: helper > args: --log --test 1`] = `
+"[log] export default function foo(positional, named) {
+  return positional;
+}
+
+[log] import { render } from '@ember/test-helpers';
+import { module, test } from 'qunit';
+import foo from 'v2-addon/helpers/foo';
+import { setupRenderingTest } from 'v2-addon/tests/helpers';
+
+module('Integration | Helper | foo', function (hooks) {
+  setupRenderingTest(hooks);
+
+  test('it renders', async function (assert) {
+    const inputValue = '1234';
+
+    await render(<template>{{foo inputValue}}</template>);
+
+    assert.dom().hasText('1234');
+  });
+});
+"
+`;
+
+exports[`package-type: v2-addon > generator: helper > args: --log --typescript 1`] = `
+"[log] export default function foo(positional, named) {
+  return positional;
+}
+"
+`;
+
+exports[`package-type: v2-addon > generator: helper > args: --log 1`] = `
+"[log] export default function foo(positional, named) {
+  return positional;
+}
+"
+`;
+
+exports[`package-type: v2-addon > generator: helper > args: --namedExport --test --typescript 1`] = `
+"[success] Generated helper \`foo\` at \`src/helpers/foo.ts\`.
+[success] Generated helper-test \`foo\` at \`tests/integration/helpers/foo-test.gts\`."
+`;
+
+exports[`package-type: v2-addon > generator: helper > args: --namedExport --test 1`] = `
+"[success] Generated helper \`foo\` at \`src/helpers/foo.js\`.
+[success] Generated helper-test \`foo\` at \`tests/integration/helpers/foo-test.gjs\`."
+`;
+
+exports[`package-type: v2-addon > generator: helper > args: --namedExport --typescript 1`] = `"[success] Generated helper \`foo\` at \`src/helpers/foo.ts\`."`;
+
+exports[`package-type: v2-addon > generator: helper > args: --namedExport 1`] = `"[success] Generated helper \`foo\` at \`src/helpers/foo.js\`."`;
+
+exports[`package-type: v2-addon > generator: helper > args: --test --typescript 1`] = `
+"[success] Generated helper \`foo\` at \`src/helpers/foo.ts\`.
+[success] Generated helper-test \`foo\` at \`tests/integration/helpers/foo-test.gts\`."
+`;
+
+exports[`package-type: v2-addon > generator: helper > args: --test 1`] = `
+"[success] Generated helper \`foo\` at \`src/helpers/foo.js\`.
+[success] Generated helper-test \`foo\` at \`tests/integration/helpers/foo-test.gjs\`."
+`;
+
+exports[`package-type: v2-addon > generator: helper > args: --typescript 1`] = `"[success] Generated helper \`foo\` at \`src/helpers/foo.ts\`."`;
+
+exports[`package-type: v2-addon > generator: helper-test > args: --log --typescript 1`] = `
+"[log] import { render } from '@ember/test-helpers';
+import { module, test } from 'qunit';
+import foo from 'v2-addon/helpers/foo';
+import { setupRenderingTest } from 'v2-addon/tests/helpers';
+
+module('Integration | Helper | foo', function (hooks) {
+  setupRenderingTest(hooks);
+
+  test('it renders', async function (assert) {
+    const inputValue = '1234';
+
+    await render(<template>{{foo inputValue}}</template>);
+
+    assert.dom().hasText('1234');
+  });
+});
+"
+`;
+
+exports[`package-type: v2-addon > generator: helper-test > args: --log 1`] = `
+"[log] import { render } from '@ember/test-helpers';
+import { module, test } from 'qunit';
+import foo from 'v2-addon/helpers/foo';
+import { setupRenderingTest } from 'v2-addon/tests/helpers';
+
+module('Integration | Helper | foo', function (hooks) {
+  setupRenderingTest(hooks);
+
+  test('it renders', async function (assert) {
+    const inputValue = '1234';
+
+    await render(<template>{{foo inputValue}}</template>);
+
+    assert.dom().hasText('1234');
+  });
+});
+"
+`;
+
+exports[`package-type: v2-addon > generator: helper-test > args: --typescript 1`] = `"[success] Generated helper-test \`foo\` at \`tests/integration/helpers/foo-test.gts\`."`;
+
+exports[`package-type: v2-addon > generator: modifier > args: --classBased --log --namedExport --test --typescript 1`] = `
+"[log] import Modifier from 'ember-modifier';
+
+type Named = {};
+type Positional = [];
+type Element = null;
+
+export interface FooSignature {
+  Args: {
+    Named: Named;
+    Positional: Positional;
+  };
+  Element: Element;
+}
+
+export class foo extends Modifier<FooSignature> {
+  modify(element: Element, positional: Positional, named: Named) {}
+}
+
+[log] import { render } from '@ember/test-helpers';
+import { module, test } from 'qunit';
+import foo from 'v2-addon/modifiers/foo';
+import { setupRenderingTest } from 'v2-addon/tests/helpers';
+
+module('Integration | Modifier | foo', function (hooks) {
+  setupRenderingTest(hooks);
+
+  test('it renders', async function (assert) {
+    await render(
+      <template>
+        <div {{foo}}></div>
+      </template>
+    );
+
+    assert.ok(true);
+  });
+});
+"
+`;
+
+exports[`package-type: v2-addon > generator: modifier > args: --classBased --log --namedExport --test 1`] = `
+"[log] import Modifier from 'ember-modifier';
+
+export class foo extends Modifier {
+  modify(element, positional, named) {}
+}
+
+[log] import { render } from '@ember/test-helpers';
+import { module, test } from 'qunit';
+import foo from 'v2-addon/modifiers/foo';
+import { setupRenderingTest } from 'v2-addon/tests/helpers';
+
+module('Integration | Modifier | foo', function (hooks) {
+  setupRenderingTest(hooks);
+
+  test('it renders', async function (assert) {
+    await render(
+      <template>
+        <div {{foo}}></div>
+      </template>
+    );
+
+    assert.ok(true);
+  });
+});
+"
+`;
+
+exports[`package-type: v2-addon > generator: modifier > args: --classBased --log --namedExport --typescript 1`] = `
+"[log] import Modifier from 'ember-modifier';
+
+type Named = {};
+type Positional = [];
+type Element = null;
+
+export interface FooSignature {
+  Args: {
+    Named: Named;
+    Positional: Positional;
+  };
+  Element: Element;
+}
+
+export class foo extends Modifier<FooSignature> {
+  modify(element: Element, positional: Positional, named: Named) {}
+}
+"
+`;
+
+exports[`package-type: v2-addon > generator: modifier > args: --classBased --log --namedExport 1`] = `
+"[log] import Modifier from 'ember-modifier';
+
+export class foo extends Modifier {
+  modify(element, positional, named) {}
+}
+"
+`;
+
+exports[`package-type: v2-addon > generator: modifier > args: --classBased --log --test --typescript 1`] = `
+"[log] import Modifier from 'ember-modifier';
+
+type Named = {};
+type Positional = [];
+type Element = null;
+
+export interface FooSignature {
+  Args: {
+    Named: Named;
+    Positional: Positional;
+  };
+  Element: Element;
+}
+
+export default class foo extends Modifier<FooSignature> {
+  modify(element: Element, positional: Positional, named: Named) {}
+}
+
+[log] import { render } from '@ember/test-helpers';
+import { module, test } from 'qunit';
+import foo from 'v2-addon/modifiers/foo';
+import { setupRenderingTest } from 'v2-addon/tests/helpers';
+
+module('Integration | Modifier | foo', function (hooks) {
+  setupRenderingTest(hooks);
+
+  test('it renders', async function (assert) {
+    await render(
+      <template>
+        <div {{foo}}></div>
+      </template>
+    );
+
+    assert.ok(true);
+  });
+});
+"
+`;
+
+exports[`package-type: v2-addon > generator: modifier > args: --classBased --log --test 1`] = `
+"[log] import Modifier from 'ember-modifier';
+
+export default class foo extends Modifier {
+  modify(element, positional, named) {}
+}
+
+[log] import { render } from '@ember/test-helpers';
+import { module, test } from 'qunit';
+import foo from 'v2-addon/modifiers/foo';
+import { setupRenderingTest } from 'v2-addon/tests/helpers';
+
+module('Integration | Modifier | foo', function (hooks) {
+  setupRenderingTest(hooks);
+
+  test('it renders', async function (assert) {
+    await render(
+      <template>
+        <div {{foo}}></div>
+      </template>
+    );
+
+    assert.ok(true);
+  });
+});
+"
+`;
+
+exports[`package-type: v2-addon > generator: modifier > args: --classBased --log --typescript 1`] = `
+"[log] import Modifier from 'ember-modifier';
+
+type Named = {};
+type Positional = [];
+type Element = null;
+
+export interface FooSignature {
+  Args: {
+    Named: Named;
+    Positional: Positional;
+  };
+  Element: Element;
+}
+
+export default class foo extends Modifier<FooSignature> {
+  modify(element: Element, positional: Positional, named: Named) {}
+}
+"
+`;
+
+exports[`package-type: v2-addon > generator: modifier > args: --classBased --log 1`] = `
+"[log] import Modifier from 'ember-modifier';
+
+export default class foo extends Modifier {
+  modify(element, positional, named) {}
+}
+"
+`;
+
+exports[`package-type: v2-addon > generator: modifier > args: --classBased --namedExport --test --typescript 1`] = `
+"[success] Generated modifier \`foo\` at \`src/modifiers/foo.ts\`.
+[success] Generated modifier-test \`foo\` at \`tests/integration/modifiers/foo-test.gts\`."
+`;
+
+exports[`package-type: v2-addon > generator: modifier > args: --classBased --namedExport --test 1`] = `
+"[success] Generated modifier \`foo\` at \`src/modifiers/foo.js\`.
+[success] Generated modifier-test \`foo\` at \`tests/integration/modifiers/foo-test.gjs\`."
+`;
+
+exports[`package-type: v2-addon > generator: modifier > args: --classBased --namedExport --typescript 1`] = `"[success] Generated modifier \`foo\` at \`src/modifiers/foo.ts\`."`;
+
+exports[`package-type: v2-addon > generator: modifier > args: --classBased --namedExport 1`] = `"[success] Generated modifier \`foo\` at \`src/modifiers/foo.js\`."`;
+
+exports[`package-type: v2-addon > generator: modifier > args: --classBased --test --typescript 1`] = `
+"[success] Generated modifier \`foo\` at \`src/modifiers/foo.ts\`.
+[success] Generated modifier-test \`foo\` at \`tests/integration/modifiers/foo-test.gts\`."
+`;
+
+exports[`package-type: v2-addon > generator: modifier > args: --classBased --test 1`] = `
+"[success] Generated modifier \`foo\` at \`src/modifiers/foo.js\`.
+[success] Generated modifier-test \`foo\` at \`tests/integration/modifiers/foo-test.gjs\`."
+`;
+
+exports[`package-type: v2-addon > generator: modifier > args: --classBased --typescript 1`] = `"[success] Generated modifier \`foo\` at \`src/modifiers/foo.ts\`."`;
+
+exports[`package-type: v2-addon > generator: modifier > args: --classBased 1`] = `"[success] Generated modifier \`foo\` at \`src/modifiers/foo.js\`."`;
+
+exports[`package-type: v2-addon > generator: modifier > args: --log --namedExport --test --typescript 1`] = `
+"[log] import { modifier } from 'ember-modifier';
+
+export interface FooSignature {
+  Args: {
+    Named: {};
+    Positional: [];
+  };
+  Element: null;
+}
+
+export const foo = modifier<FooSignature>(function foo(element, positional, named) {});
+
+[log] import { render } from '@ember/test-helpers';
+import { module, test } from 'qunit';
+import foo from 'v2-addon/modifiers/foo';
+import { setupRenderingTest } from 'v2-addon/tests/helpers';
+
+module('Integration | Modifier | foo', function (hooks) {
+  setupRenderingTest(hooks);
+
+  test('it renders', async function (assert) {
+    await render(
+      <template>
+        <div {{foo}}></div>
+      </template>
+    );
+
+    assert.ok(true);
+  });
+});
+"
+`;
+
+exports[`package-type: v2-addon > generator: modifier > args: --log --namedExport --test 1`] = `
+"[log] import { modifier } from 'ember-modifier';
+
+export const foo = modifier(function foo(element, positional, named) {});
+
+[log] import { render } from '@ember/test-helpers';
+import { module, test } from 'qunit';
+import foo from 'v2-addon/modifiers/foo';
+import { setupRenderingTest } from 'v2-addon/tests/helpers';
+
+module('Integration | Modifier | foo', function (hooks) {
+  setupRenderingTest(hooks);
+
+  test('it renders', async function (assert) {
+    await render(
+      <template>
+        <div {{foo}}></div>
+      </template>
+    );
+
+    assert.ok(true);
+  });
+});
+"
+`;
+
+exports[`package-type: v2-addon > generator: modifier > args: --log --namedExport --typescript 1`] = `
+"[log] import { modifier } from 'ember-modifier';
+
+export interface FooSignature {
+  Args: {
+    Named: {};
+    Positional: [];
+  };
+  Element: null;
+}
+
+export const foo = modifier<FooSignature>(function foo(element, positional, named) {});
+"
+`;
+
+exports[`package-type: v2-addon > generator: modifier > args: --log --namedExport 1`] = `
+"[log] import { modifier } from 'ember-modifier';
+
+export const foo = modifier(function foo(element, positional, named) {});
+"
+`;
+
+exports[`package-type: v2-addon > generator: modifier > args: --log --test --typescript 1`] = `
+"[log] import { modifier } from 'ember-modifier';
+
+export interface FooSignature {
+  Args: {
+    Named: {};
+    Positional: [];
+  };
+  Element: null;
+}
+
+export default modifier<FooSignature>(function foo(element, positional, named) {});
+
+[log] import { render } from '@ember/test-helpers';
+import { module, test } from 'qunit';
+import foo from 'v2-addon/modifiers/foo';
+import { setupRenderingTest } from 'v2-addon/tests/helpers';
+
+module('Integration | Modifier | foo', function (hooks) {
+  setupRenderingTest(hooks);
+
+  test('it renders', async function (assert) {
+    await render(
+      <template>
+        <div {{foo}}></div>
+      </template>
+    );
+
+    assert.ok(true);
+  });
+});
+"
+`;
+
+exports[`package-type: v2-addon > generator: modifier > args: --log --test 1`] = `
+"[log] import { modifier } from 'ember-modifier';
+
+export default modifier(function foo(element, positional, named) {});
+
+[log] import { render } from '@ember/test-helpers';
+import { module, test } from 'qunit';
+import foo from 'v2-addon/modifiers/foo';
+import { setupRenderingTest } from 'v2-addon/tests/helpers';
+
+module('Integration | Modifier | foo', function (hooks) {
+  setupRenderingTest(hooks);
+
+  test('it renders', async function (assert) {
+    await render(
+      <template>
+        <div {{foo}}></div>
+      </template>
+    );
+
+    assert.ok(true);
+  });
+});
+"
+`;
+
+exports[`package-type: v2-addon > generator: modifier > args: --log --typescript 1`] = `
+"[log] import { modifier } from 'ember-modifier';
+
+export interface FooSignature {
+  Args: {
+    Named: {};
+    Positional: [];
+  };
+  Element: null;
+}
+
+export default modifier<FooSignature>(function foo(element, positional, named) {});
+"
+`;
+
+exports[`package-type: v2-addon > generator: modifier > args: --log 1`] = `
+"[log] import { modifier } from 'ember-modifier';
+
+export default modifier(function foo(element, positional, named) {});
+"
+`;
+
+exports[`package-type: v2-addon > generator: modifier > args: --namedExport --test --typescript 1`] = `
+"[success] Generated modifier \`foo\` at \`src/modifiers/foo.ts\`.
+[success] Generated modifier-test \`foo\` at \`tests/integration/modifiers/foo-test.gts\`."
+`;
+
+exports[`package-type: v2-addon > generator: modifier > args: --namedExport --test 1`] = `
+"[success] Generated modifier \`foo\` at \`src/modifiers/foo.js\`.
+[success] Generated modifier-test \`foo\` at \`tests/integration/modifiers/foo-test.gjs\`."
+`;
+
+exports[`package-type: v2-addon > generator: modifier > args: --namedExport --typescript 1`] = `"[success] Generated modifier \`foo\` at \`src/modifiers/foo.ts\`."`;
+
+exports[`package-type: v2-addon > generator: modifier > args: --namedExport 1`] = `"[success] Generated modifier \`foo\` at \`src/modifiers/foo.js\`."`;
+
+exports[`package-type: v2-addon > generator: modifier > args: --test --typescript 1`] = `
+"[success] Generated modifier \`foo\` at \`src/modifiers/foo.ts\`.
+[success] Generated modifier-test \`foo\` at \`tests/integration/modifiers/foo-test.gts\`."
+`;
+
+exports[`package-type: v2-addon > generator: modifier > args: --test 1`] = `
+"[success] Generated modifier \`foo\` at \`src/modifiers/foo.js\`.
+[success] Generated modifier-test \`foo\` at \`tests/integration/modifiers/foo-test.gjs\`."
+`;
+
+exports[`package-type: v2-addon > generator: modifier > args: --typescript 1`] = `"[success] Generated modifier \`foo\` at \`src/modifiers/foo.ts\`."`;
+
+exports[`package-type: v2-addon > generator: modifier-test > args: --log --typescript 1`] = `
+"[log] import { render } from '@ember/test-helpers';
+import { module, test } from 'qunit';
+import foo from 'v2-addon/modifiers/foo';
+import { setupRenderingTest } from 'v2-addon/tests/helpers';
+
+module('Integration | Modifier | foo', function (hooks) {
+  setupRenderingTest(hooks);
+
+  test('it renders', async function (assert) {
+    await render(
+      <template>
+        <div {{foo}}></div>
+      </template>
+    );
+
+    assert.ok(true);
+  });
+});
+"
+`;
+
+exports[`package-type: v2-addon > generator: modifier-test > args: --log 1`] = `
+"[log] import { render } from '@ember/test-helpers';
+import { module, test } from 'qunit';
+import foo from 'v2-addon/modifiers/foo';
+import { setupRenderingTest } from 'v2-addon/tests/helpers';
+
+module('Integration | Modifier | foo', function (hooks) {
+  setupRenderingTest(hooks);
+
+  test('it renders', async function (assert) {
+    await render(
+      <template>
+        <div {{foo}}></div>
+      </template>
+    );
+
+    assert.ok(true);
+  });
+});
+"
+`;
+
+exports[`package-type: v2-addon > generator: modifier-test > args: --typescript 1`] = `"[success] Generated modifier-test \`foo\` at \`tests/integration/modifiers/foo-test.gts\`."`;
+
+exports[`package-type: v2-addon > generator: route > args: --log --test --typescript 1`] = `
+"[log] import Route from '@ember/routing/route';
+
+export default class FooRoute extends Route {}
+
+[log] import { module, test } from 'qunit';
+import { setupTest } from 'v2-addon/tests/helpers';
+
+module('Unit | Route | Foo', function (hooks) {
+  setupTest(hooks);
+
+  test('it exists', function (assert) {
+    const route = this.owner.lookup('route:foo');
+
+    assert.ok(route);
+  });
+});
+"
+`;
+
+exports[`package-type: v2-addon > generator: route > args: --log --test 1`] = `
+"[log] import Route from '@ember/routing/route';
+
+export default class FooRoute extends Route {}
+
+[log] import { module, test } from 'qunit';
+import { setupTest } from 'v2-addon/tests/helpers';
+
+module('Unit | Route | Foo', function (hooks) {
+  setupTest(hooks);
+
+  test('it exists', function (assert) {
+    const route = this.owner.lookup('route:foo');
+
+    assert.ok(route);
+  });
+});
+"
+`;
+
+exports[`package-type: v2-addon > generator: route > args: --log --typescript 1`] = `
+"[log] import Route from '@ember/routing/route';
+
+export default class FooRoute extends Route {}
+"
+`;
+
+exports[`package-type: v2-addon > generator: route > args: --log 1`] = `
+"[log] import Route from '@ember/routing/route';
+
+export default class FooRoute extends Route {}
+"
+`;
+
+exports[`package-type: v2-addon > generator: route > args: --test --typescript 1`] = `
+"[success] Generated route \`foo\` at \`src/routes/foo.ts\`.
+[success] Generated route-test \`foo\` at \`tests/unit/routes/foo-test.ts\`."
+`;
+
+exports[`package-type: v2-addon > generator: route > args: --test 1`] = `
+"[success] Generated route \`foo\` at \`src/routes/foo.js\`.
+[success] Generated route-test \`foo\` at \`tests/unit/routes/foo-test.js\`."
+`;
+
+exports[`package-type: v2-addon > generator: route > args: --typescript 1`] = `"[success] Generated route \`foo\` at \`src/routes/foo.ts\`."`;
+
+exports[`package-type: v2-addon > generator: route-test > args: --log --typescript 1`] = `
+"[log] import { module, test } from 'qunit';
+import { setupTest } from 'v2-addon/tests/helpers';
+
+module('Unit | Route | Foo', function (hooks) {
+  setupTest(hooks);
+
+  test('it exists', function (assert) {
+    const route = this.owner.lookup('route:foo');
+
+    assert.ok(route);
+  });
+});
+"
+`;
+
+exports[`package-type: v2-addon > generator: route-test > args: --log 1`] = `
+"[log] import { module, test } from 'qunit';
+import { setupTest } from 'v2-addon/tests/helpers';
+
+module('Unit | Route | Foo', function (hooks) {
+  setupTest(hooks);
+
+  test('it exists', function (assert) {
+    const route = this.owner.lookup('route:foo');
+
+    assert.ok(route);
+  });
+});
+"
+`;
+
+exports[`package-type: v2-addon > generator: route-test > args: --typescript 1`] = `"[success] Generated route-test \`foo\` at \`tests/unit/routes/foo-test.ts\`."`;
+
+exports[`package-type: v2-addon > generator: service > args: --log --test --typescript 1`] = `
+"[log] import Service from '@ember/service';
+
+export default class FooService extends Service {}
+
+declare module '@ember/service' {
+  interface Registry {
+    foo: FooService;
+  }
+}
+
+[log] import { module, test } from 'qunit';
+import { setupTest } from 'v2-addon/tests/helpers';
+
+module('Unit | Service | Foo', function (hooks) {
+  setupTest(hooks);
+
+  test('it exists', function (assert) {
+    const service = this.owner.lookup('service:foo');
+
+    assert.ok(service);
+  });
+});
+"
+`;
+
+exports[`package-type: v2-addon > generator: service > args: --log --test 1`] = `
+"[log] import Service from '@ember/service';
+
+export default class FooService extends Service {}
+
+[log] import { module, test } from 'qunit';
+import { setupTest } from 'v2-addon/tests/helpers';
+
+module('Unit | Service | Foo', function (hooks) {
+  setupTest(hooks);
+
+  test('it exists', function (assert) {
+    const service = this.owner.lookup('service:foo');
+
+    assert.ok(service);
+  });
+});
+"
+`;
+
+exports[`package-type: v2-addon > generator: service > args: --log --typescript 1`] = `
+"[log] import Service from '@ember/service';
+
+export default class FooService extends Service {}
+
+declare module '@ember/service' {
+  interface Registry {
+    foo: FooService;
+  }
+}
+"
+`;
+
+exports[`package-type: v2-addon > generator: service > args: --log 1`] = `
+"[log] import Service from '@ember/service';
+
+export default class FooService extends Service {}
+"
+`;
+
+exports[`package-type: v2-addon > generator: service > args: --test --typescript 1`] = `
+"[success] Generated service \`foo\` at \`src/services/foo.ts\`.
+[success] Generated service-test \`foo\` at \`tests/unit/services/foo-test.ts\`."
+`;
+
+exports[`package-type: v2-addon > generator: service > args: --test 1`] = `
+"[success] Generated service \`foo\` at \`src/services/foo.js\`.
+[success] Generated service-test \`foo\` at \`tests/unit/services/foo-test.js\`."
+`;
+
+exports[`package-type: v2-addon > generator: service > args: --typescript 1`] = `"[success] Generated service \`foo\` at \`src/services/foo.ts\`."`;
+
+exports[`package-type: v2-addon > generator: service-test > args: --log --typescript 1`] = `
+"[log] import { module, test } from 'qunit';
+import { setupTest } from 'v2-addon/tests/helpers';
+
+module('Unit | Service | Foo', function (hooks) {
+  setupTest(hooks);
+
+  test('it exists', function (assert) {
+    const service = this.owner.lookup('service:foo');
+
+    assert.ok(service);
+  });
+});
+"
+`;
+
+exports[`package-type: v2-addon > generator: service-test > args: --log 1`] = `
+"[log] import { module, test } from 'qunit';
+import { setupTest } from 'v2-addon/tests/helpers';
+
+module('Unit | Service | Foo', function (hooks) {
+  setupTest(hooks);
+
+  test('it exists', function (assert) {
+    const service = this.owner.lookup('service:foo');
+
+    assert.ok(service);
+  });
+});
+"
+`;
+
+exports[`package-type: v2-addon > generator: service-test > args: --typescript 1`] = `"[success] Generated service-test \`foo\` at \`tests/unit/services/foo-test.ts\`."`;
+
+exports[`package-type: v2-addon > generator: util > args: --log --namedExport --test --typescript 1`] = `
+"[log] export function foo() {
+  return true;
+}
+
+[log] import foo from 'v2-addon/utils/foo';
+import { module, test } from 'qunit';
+
+module('Unit | Util | foo', function () {
+  test('it works', function (assert) {
+    const result = foo();
+
+    assert.ok(result);
+  });
+});
+"
+`;
+
+exports[`package-type: v2-addon > generator: util > args: --log --namedExport --test 1`] = `
+"[log] export function foo() {
+  return true;
+}
+
+[log] import foo from 'v2-addon/utils/foo';
+import { module, test } from 'qunit';
+
+module('Unit | Util | foo', function () {
+  test('it works', function (assert) {
+    const result = foo();
+
+    assert.ok(result);
+  });
+});
+"
+`;
+
+exports[`package-type: v2-addon > generator: util > args: --log --namedExport --typescript 1`] = `
+"[log] export function foo() {
+  return true;
+}
+"
+`;
+
+exports[`package-type: v2-addon > generator: util > args: --log --namedExport 1`] = `
+"[log] export function foo() {
+  return true;
+}
+"
+`;
+
+exports[`package-type: v2-addon > generator: util > args: --log --test --typescript 1`] = `
+"[log] export default function foo() {
+  return true;
+}
+
+[log] import foo from 'v2-addon/utils/foo';
+import { module, test } from 'qunit';
+
+module('Unit | Util | foo', function () {
+  test('it works', function (assert) {
+    const result = foo();
+
+    assert.ok(result);
+  });
+});
+"
+`;
+
+exports[`package-type: v2-addon > generator: util > args: --log --test 1`] = `
+"[log] export default function foo() {
+  return true;
+}
+
+[log] import foo from 'v2-addon/utils/foo';
+import { module, test } from 'qunit';
+
+module('Unit | Util | foo', function () {
+  test('it works', function (assert) {
+    const result = foo();
+
+    assert.ok(result);
+  });
+});
+"
+`;
+
+exports[`package-type: v2-addon > generator: util > args: --log --typescript 1`] = `
+"[log] export default function foo() {
+  return true;
+}
+"
+`;
+
+exports[`package-type: v2-addon > generator: util > args: --log 1`] = `
+"[log] export default function foo() {
+  return true;
+}
+"
+`;
+
+exports[`package-type: v2-addon > generator: util > args: --namedExport --test --typescript 1`] = `
+"[success] Generated util \`foo\` at \`src/utils/foo.ts\`.
+[success] Generated util-test \`foo\` at \`tests/unit/utils/foo-test.ts\`."
+`;
+
+exports[`package-type: v2-addon > generator: util > args: --namedExport --test 1`] = `
+"[success] Generated util \`foo\` at \`src/utils/foo.js\`.
+[success] Generated util-test \`foo\` at \`tests/unit/utils/foo-test.js\`."
+`;
+
+exports[`package-type: v2-addon > generator: util > args: --namedExport --typescript 1`] = `"[success] Generated util \`foo\` at \`src/utils/foo.ts\`."`;
+
+exports[`package-type: v2-addon > generator: util > args: --namedExport 1`] = `"[success] Generated util \`foo\` at \`src/utils/foo.js\`."`;
+
+exports[`package-type: v2-addon > generator: util > args: --test --typescript 1`] = `
+"[success] Generated util \`foo\` at \`src/utils/foo.ts\`.
+[success] Generated util-test \`foo\` at \`tests/unit/utils/foo-test.ts\`."
+`;
+
+exports[`package-type: v2-addon > generator: util > args: --test 1`] = `
+"[success] Generated util \`foo\` at \`src/utils/foo.js\`.
+[success] Generated util-test \`foo\` at \`tests/unit/utils/foo-test.js\`."
+`;
+
+exports[`package-type: v2-addon > generator: util > args: --typescript 1`] = `"[success] Generated util \`foo\` at \`src/utils/foo.ts\`."`;
+
+exports[`package-type: v2-addon > generator: util-test > args: --log --typescript 1`] = `
+"[log] import foo from 'v2-addon/utils/foo';
+import { module, test } from 'qunit';
+
+module('Unit | Util | foo', function () {
+  test('it works', function (assert) {
+    const result = foo();
+
+    assert.ok(result);
+  });
+});
+"
+`;
+
+exports[`package-type: v2-addon > generator: util-test > args: --log 1`] = `
+"[log] import foo from 'v2-addon/utils/foo';
+import { module, test } from 'qunit';
+
+module('Unit | Util | foo', function () {
+  test('it works', function (assert) {
+    const result = foo();
+
+    assert.ok(result);
+  });
+});
+"
+`;
+
+exports[`package-type: v2-addon > generator: util-test > args: --typescript 1`] = `"[success] Generated util-test \`foo\` at \`tests/unit/utils/foo-test.ts\`."`;
+
+exports[`package-type: v2-app > generator: acceptance-test > args: --log --typescript 1`] = `
+"[log] import { currentURL, visit } from '@ember/test-helpers';
+import { module, test } from 'qunit';
+import { setupApplicationTest } from 'ember-qunit';
+
+module('Acceptance | foo', function (hooks) {
+  setupApplicationTest(hooks);
+
+  test('it visits /foo', async function (assert) {
+    await visit('/foo');
+
+    assert.strictEqual(currentURL(), '/foo');
+  });
+});
+"
+`;
+
+exports[`package-type: v2-app > generator: acceptance-test > args: --log 1`] = `
+"[log] import { currentURL, visit } from '@ember/test-helpers';
+import { module, test } from 'qunit';
+import { setupApplicationTest } from 'ember-qunit';
+
+module('Acceptance | foo', function (hooks) {
+  setupApplicationTest(hooks);
+
+  test('it visits /foo', async function (assert) {
+    await visit('/foo');
+
+    assert.strictEqual(currentURL(), '/foo');
+  });
+});
+"
+`;
+
+exports[`package-type: v2-app > generator: acceptance-test > args: --typescript 1`] = `"[success] Generated acceptance-test \`foo\` at \`tests/acceptance/foo-test.ts\`."`;
+
+exports[`package-type: v2-app > generator: component > args: --classBased --log --namedExport --nested --test --typescript 1`] = `
+"[log] import Component from '@glimmer/component';
+
+export interface FooSignature {
+  Args: {};
+  Blocks: {
+    default: [];
+  };
+  Element: null;
+}
+
+export class Foo extends Component<FooSignature> {
+  <template>
+    {{yield}}
+  </template>
+}
+
+[log] import { render } from '@ember/test-helpers';
+import { module, test } from 'qunit';
+import Foo from 'v2-app/components/foo';
+import { setupRenderingTest } from 'ember-qunit';
+
+module('Integration | Component | Foo', function (hooks) {
+  setupRenderingTest(hooks);
+
+  test('it renders', async function (assert) {
+    await render(<template><Foo /></template>);
+
+    assert.dom().hasText('');
+
+    await render(
+      <template>
+        <Foo>
+          template block text
+        </Foo>
+      </template>
+    );
+
+    assert.dom().hasText('template block text');
+  });
+});
+"
+`;
+
+exports[`package-type: v2-app > generator: component > args: --classBased --log --namedExport --nested --test 1`] = `
+"[log] import Component from '@glimmer/component';
+
+export class Foo extends Component {
+  <template>{{yield}}</template>
+}
+
+[log] import { render } from '@ember/test-helpers';
+import { module, test } from 'qunit';
+import Foo from 'v2-app/components/foo';
+import { setupRenderingTest } from 'ember-qunit';
+
+module('Integration | Component | Foo', function (hooks) {
+  setupRenderingTest(hooks);
+
+  test('it renders', async function (assert) {
+    await render(<template><Foo /></template>);
+
+    assert.dom().hasText('');
+
+    await render(
+      <template>
+        <Foo>
+          template block text
+        </Foo>
+      </template>
+    );
+
+    assert.dom().hasText('template block text');
+  });
+});
+"
+`;
+
+exports[`package-type: v2-app > generator: component > args: --classBased --log --namedExport --nested --typescript 1`] = `
+"[log] import Component from '@glimmer/component';
+
+export interface FooSignature {
+  Args: {};
+  Blocks: {
+    default: [];
+  };
+  Element: null;
+}
+
+export class Foo extends Component<FooSignature> {
+  <template>
+    {{yield}}
+  </template>
+}
+"
+`;
+
+exports[`package-type: v2-app > generator: component > args: --classBased --log --namedExport --nested 1`] = `
+"[log] import Component from '@glimmer/component';
+
+export class Foo extends Component {
+  <template>{{yield}}</template>
+}
+"
+`;
+
+exports[`package-type: v2-app > generator: component > args: --classBased --log --namedExport --test --typescript 1`] = `
+"[log] import Component from '@glimmer/component';
+
+export interface FooSignature {
+  Args: {};
+  Blocks: {
+    default: [];
+  };
+  Element: null;
+}
+
+export class Foo extends Component<FooSignature> {
+  <template>
+    {{yield}}
+  </template>
+}
+
+[log] import { render } from '@ember/test-helpers';
+import { module, test } from 'qunit';
+import Foo from 'v2-app/components/foo';
+import { setupRenderingTest } from 'ember-qunit';
+
+module('Integration | Component | Foo', function (hooks) {
+  setupRenderingTest(hooks);
+
+  test('it renders', async function (assert) {
+    await render(<template><Foo /></template>);
+
+    assert.dom().hasText('');
+
+    await render(
+      <template>
+        <Foo>
+          template block text
+        </Foo>
+      </template>
+    );
+
+    assert.dom().hasText('template block text');
+  });
+});
+"
+`;
+
+exports[`package-type: v2-app > generator: component > args: --classBased --log --namedExport --test 1`] = `
+"[log] import Component from '@glimmer/component';
+
+export class Foo extends Component {
+  <template>{{yield}}</template>
+}
+
+[log] import { render } from '@ember/test-helpers';
+import { module, test } from 'qunit';
+import Foo from 'v2-app/components/foo';
+import { setupRenderingTest } from 'ember-qunit';
+
+module('Integration | Component | Foo', function (hooks) {
+  setupRenderingTest(hooks);
+
+  test('it renders', async function (assert) {
+    await render(<template><Foo /></template>);
+
+    assert.dom().hasText('');
+
+    await render(
+      <template>
+        <Foo>
+          template block text
+        </Foo>
+      </template>
+    );
+
+    assert.dom().hasText('template block text');
+  });
+});
+"
+`;
+
+exports[`package-type: v2-app > generator: component > args: --classBased --log --namedExport --typescript 1`] = `
+"[log] import Component from '@glimmer/component';
+
+export interface FooSignature {
+  Args: {};
+  Blocks: {
+    default: [];
+  };
+  Element: null;
+}
+
+export class Foo extends Component<FooSignature> {
+  <template>
+    {{yield}}
+  </template>
+}
+"
+`;
+
+exports[`package-type: v2-app > generator: component > args: --classBased --log --namedExport 1`] = `
+"[log] import Component from '@glimmer/component';
+
+export class Foo extends Component {
+  <template>{{yield}}</template>
+}
+"
+`;
+
+exports[`package-type: v2-app > generator: component > args: --classBased --log --nested --test --typescript 1`] = `
+"[log] import Component from '@glimmer/component';
+
+export interface FooSignature {
+  Args: {};
+  Blocks: {
+    default: [];
+  };
+  Element: null;
+}
+
+export default class Foo extends Component<FooSignature> {
+  <template>
+    {{yield}}
+  </template>
+}
+
+[log] import { render } from '@ember/test-helpers';
+import { module, test } from 'qunit';
+import Foo from 'v2-app/components/foo';
+import { setupRenderingTest } from 'ember-qunit';
+
+module('Integration | Component | Foo', function (hooks) {
+  setupRenderingTest(hooks);
+
+  test('it renders', async function (assert) {
+    await render(<template><Foo /></template>);
+
+    assert.dom().hasText('');
+
+    await render(
+      <template>
+        <Foo>
+          template block text
+        </Foo>
+      </template>
+    );
+
+    assert.dom().hasText('template block text');
+  });
+});
+"
+`;
+
+exports[`package-type: v2-app > generator: component > args: --classBased --log --nested --test 1`] = `
+"[log] import Component from '@glimmer/component';
+
+export default class Foo extends Component {
+  <template>{{yield}}</template>
+}
+
+[log] import { render } from '@ember/test-helpers';
+import { module, test } from 'qunit';
+import Foo from 'v2-app/components/foo';
+import { setupRenderingTest } from 'ember-qunit';
+
+module('Integration | Component | Foo', function (hooks) {
+  setupRenderingTest(hooks);
+
+  test('it renders', async function (assert) {
+    await render(<template><Foo /></template>);
+
+    assert.dom().hasText('');
+
+    await render(
+      <template>
+        <Foo>
+          template block text
+        </Foo>
+      </template>
+    );
+
+    assert.dom().hasText('template block text');
+  });
+});
+"
+`;
+
+exports[`package-type: v2-app > generator: component > args: --classBased --log --nested --typescript 1`] = `
+"[log] import Component from '@glimmer/component';
+
+export interface FooSignature {
+  Args: {};
+  Blocks: {
+    default: [];
+  };
+  Element: null;
+}
+
+export default class Foo extends Component<FooSignature> {
+  <template>
+    {{yield}}
+  </template>
+}
+"
+`;
+
+exports[`package-type: v2-app > generator: component > args: --classBased --log --nested 1`] = `
+"[log] import Component from '@glimmer/component';
+
+export default class Foo extends Component {
+  <template>{{yield}}</template>
+}
+"
+`;
+
+exports[`package-type: v2-app > generator: component > args: --classBased --log --test --typescript 1`] = `
+"[log] import Component from '@glimmer/component';
+
+export interface FooSignature {
+  Args: {};
+  Blocks: {
+    default: [];
+  };
+  Element: null;
+}
+
+export default class Foo extends Component<FooSignature> {
+  <template>
+    {{yield}}
+  </template>
+}
+
+[log] import { render } from '@ember/test-helpers';
+import { module, test } from 'qunit';
+import Foo from 'v2-app/components/foo';
+import { setupRenderingTest } from 'ember-qunit';
+
+module('Integration | Component | Foo', function (hooks) {
+  setupRenderingTest(hooks);
+
+  test('it renders', async function (assert) {
+    await render(<template><Foo /></template>);
+
+    assert.dom().hasText('');
+
+    await render(
+      <template>
+        <Foo>
+          template block text
+        </Foo>
+      </template>
+    );
+
+    assert.dom().hasText('template block text');
+  });
+});
+"
+`;
+
+exports[`package-type: v2-app > generator: component > args: --classBased --log --test 1`] = `
+"[log] import Component from '@glimmer/component';
+
+export default class Foo extends Component {
+  <template>{{yield}}</template>
+}
+
+[log] import { render } from '@ember/test-helpers';
+import { module, test } from 'qunit';
+import Foo from 'v2-app/components/foo';
+import { setupRenderingTest } from 'ember-qunit';
+
+module('Integration | Component | Foo', function (hooks) {
+  setupRenderingTest(hooks);
+
+  test('it renders', async function (assert) {
+    await render(<template><Foo /></template>);
+
+    assert.dom().hasText('');
+
+    await render(
+      <template>
+        <Foo>
+          template block text
+        </Foo>
+      </template>
+    );
+
+    assert.dom().hasText('template block text');
+  });
+});
+"
+`;
+
+exports[`package-type: v2-app > generator: component > args: --classBased --log --typescript 1`] = `
+"[log] import Component from '@glimmer/component';
+
+export interface FooSignature {
+  Args: {};
+  Blocks: {
+    default: [];
+  };
+  Element: null;
+}
+
+export default class Foo extends Component<FooSignature> {
+  <template>
+    {{yield}}
+  </template>
+}
+"
+`;
+
+exports[`package-type: v2-app > generator: component > args: --classBased --log 1`] = `
+"[log] import Component from '@glimmer/component';
+
+export default class Foo extends Component {
+  <template>{{yield}}</template>
+}
+"
+`;
+
+exports[`package-type: v2-app > generator: component > args: --classBased --namedExport --nested --test --typescript 1`] = `
+"[success] Generated component \`foo\` at \`app/components/foo/index.gts\`.
+[success] Generated component-test \`foo\` at \`tests/integration/components/foo-test.gts\`."
+`;
+
+exports[`package-type: v2-app > generator: component > args: --classBased --namedExport --nested --test 1`] = `
+"[success] Generated component \`foo\` at \`app/components/foo/index.gjs\`.
+[success] Generated component-test \`foo\` at \`tests/integration/components/foo-test.gjs\`."
+`;
+
+exports[`package-type: v2-app > generator: component > args: --classBased --namedExport --nested --typescript 1`] = `"[success] Generated component \`foo\` at \`app/components/foo/index.gts\`."`;
+
+exports[`package-type: v2-app > generator: component > args: --classBased --namedExport --nested 1`] = `"[success] Generated component \`foo\` at \`app/components/foo/index.gjs\`."`;
+
+exports[`package-type: v2-app > generator: component > args: --classBased --namedExport --test --typescript 1`] = `
+"[success] Generated component \`foo\` at \`app/components/foo.gts\`.
+[success] Generated component-test \`foo\` at \`tests/integration/components/foo-test.gts\`."
+`;
+
+exports[`package-type: v2-app > generator: component > args: --classBased --namedExport --test 1`] = `
+"[success] Generated component \`foo\` at \`app/components/foo.gjs\`.
+[success] Generated component-test \`foo\` at \`tests/integration/components/foo-test.gjs\`."
+`;
+
+exports[`package-type: v2-app > generator: component > args: --classBased --namedExport --typescript 1`] = `"[success] Generated component \`foo\` at \`app/components/foo.gts\`."`;
+
+exports[`package-type: v2-app > generator: component > args: --classBased --namedExport 1`] = `"[success] Generated component \`foo\` at \`app/components/foo.gjs\`."`;
+
+exports[`package-type: v2-app > generator: component > args: --classBased --nested --test --typescript 1`] = `
+"[success] Generated component \`foo\` at \`app/components/foo/index.gts\`.
+[success] Generated component-test \`foo\` at \`tests/integration/components/foo-test.gts\`."
+`;
+
+exports[`package-type: v2-app > generator: component > args: --classBased --nested --test 1`] = `
+"[success] Generated component \`foo\` at \`app/components/foo/index.gjs\`.
+[success] Generated component-test \`foo\` at \`tests/integration/components/foo-test.gjs\`."
+`;
+
+exports[`package-type: v2-app > generator: component > args: --classBased --nested --typescript 1`] = `"[success] Generated component \`foo\` at \`app/components/foo/index.gts\`."`;
+
+exports[`package-type: v2-app > generator: component > args: --classBased --nested 1`] = `"[success] Generated component \`foo\` at \`app/components/foo/index.gjs\`."`;
+
+exports[`package-type: v2-app > generator: component > args: --classBased --test --typescript 1`] = `
+"[success] Generated component \`foo\` at \`app/components/foo.gts\`.
+[success] Generated component-test \`foo\` at \`tests/integration/components/foo-test.gts\`."
+`;
+
+exports[`package-type: v2-app > generator: component > args: --classBased --test 1`] = `
+"[success] Generated component \`foo\` at \`app/components/foo.gjs\`.
+[success] Generated component-test \`foo\` at \`tests/integration/components/foo-test.gjs\`."
+`;
+
+exports[`package-type: v2-app > generator: component > args: --classBased --typescript 1`] = `"[success] Generated component \`foo\` at \`app/components/foo.gts\`."`;
+
+exports[`package-type: v2-app > generator: component > args: --classBased 1`] = `"[success] Generated component \`foo\` at \`app/components/foo.gjs\`."`;
+
+exports[`package-type: v2-app > generator: component > args: --log --namedExport --nested --test --typescript 1`] = `
+"[log] import type { TOC } from '@ember/component/template-only';
+
+export interface FooSignature {
+  Args: {};
+  Blocks: {
+    default: [];
+  };
+  Element: null;
+}
+
+export const Foo: TOC<FooSignature> = <template>{{yield}}</template>;
+
+[log] import { render } from '@ember/test-helpers';
+import { module, test } from 'qunit';
+import Foo from 'v2-app/components/foo';
+import { setupRenderingTest } from 'ember-qunit';
+
+module('Integration | Component | Foo', function (hooks) {
+  setupRenderingTest(hooks);
+
+  test('it renders', async function (assert) {
+    await render(<template><Foo /></template>);
+
+    assert.dom().hasText('');
+
+    await render(
+      <template>
+        <Foo>
+          template block text
+        </Foo>
+      </template>
+    );
+
+    assert.dom().hasText('template block text');
+  });
+});
+"
+`;
+
+exports[`package-type: v2-app > generator: component > args: --log --namedExport --nested --test 1`] = `
+"[log] <template>{{yield}}</template>
+
+[log] import { render } from '@ember/test-helpers';
+import { module, test } from 'qunit';
+import Foo from 'v2-app/components/foo';
+import { setupRenderingTest } from 'ember-qunit';
+
+module('Integration | Component | Foo', function (hooks) {
+  setupRenderingTest(hooks);
+
+  test('it renders', async function (assert) {
+    await render(<template><Foo /></template>);
+
+    assert.dom().hasText('');
+
+    await render(
+      <template>
+        <Foo>
+          template block text
+        </Foo>
+      </template>
+    );
+
+    assert.dom().hasText('template block text');
+  });
+});
+"
+`;
+
+exports[`package-type: v2-app > generator: component > args: --log --namedExport --nested --typescript 1`] = `
+"[log] import type { TOC } from '@ember/component/template-only';
+
+export interface FooSignature {
+  Args: {};
+  Blocks: {
+    default: [];
+  };
+  Element: null;
+}
+
+export const Foo: TOC<FooSignature> = <template>{{yield}}</template>;
+"
+`;
+
+exports[`package-type: v2-app > generator: component > args: --log --namedExport --nested 1`] = `
+"[log] <template>{{yield}}</template>
+"
+`;
+
+exports[`package-type: v2-app > generator: component > args: --log --namedExport --test --typescript 1`] = `
+"[log] import type { TOC } from '@ember/component/template-only';
+
+export interface FooSignature {
+  Args: {};
+  Blocks: {
+    default: [];
+  };
+  Element: null;
+}
+
+export const Foo: TOC<FooSignature> = <template>{{yield}}</template>;
+
+[log] import { render } from '@ember/test-helpers';
+import { module, test } from 'qunit';
+import Foo from 'v2-app/components/foo';
+import { setupRenderingTest } from 'ember-qunit';
+
+module('Integration | Component | Foo', function (hooks) {
+  setupRenderingTest(hooks);
+
+  test('it renders', async function (assert) {
+    await render(<template><Foo /></template>);
+
+    assert.dom().hasText('');
+
+    await render(
+      <template>
+        <Foo>
+          template block text
+        </Foo>
+      </template>
+    );
+
+    assert.dom().hasText('template block text');
+  });
+});
+"
+`;
+
+exports[`package-type: v2-app > generator: component > args: --log --namedExport --test 1`] = `
+"[log] <template>{{yield}}</template>
+
+[log] import { render } from '@ember/test-helpers';
+import { module, test } from 'qunit';
+import Foo from 'v2-app/components/foo';
+import { setupRenderingTest } from 'ember-qunit';
+
+module('Integration | Component | Foo', function (hooks) {
+  setupRenderingTest(hooks);
+
+  test('it renders', async function (assert) {
+    await render(<template><Foo /></template>);
+
+    assert.dom().hasText('');
+
+    await render(
+      <template>
+        <Foo>
+          template block text
+        </Foo>
+      </template>
+    );
+
+    assert.dom().hasText('template block text');
+  });
+});
+"
+`;
+
+exports[`package-type: v2-app > generator: component > args: --log --namedExport --typescript 1`] = `
+"[log] import type { TOC } from '@ember/component/template-only';
+
+export interface FooSignature {
+  Args: {};
+  Blocks: {
+    default: [];
+  };
+  Element: null;
+}
+
+export const Foo: TOC<FooSignature> = <template>{{yield}}</template>;
+"
+`;
+
+exports[`package-type: v2-app > generator: component > args: --log --namedExport 1`] = `
+"[log] <template>{{yield}}</template>
+"
+`;
+
+exports[`package-type: v2-app > generator: component > args: --log --nested --test --typescript 1`] = `
+"[log] import type { TOC } from '@ember/component/template-only';
+
+export interface FooSignature {
+  Args: {};
+  Blocks: {
+    default: [];
+  };
+  Element: null;
+}
+
+const Foo: TOC<FooSignature> = <template>{{yield}}</template>;
+
+export default Foo;
+
+[log] import { render } from '@ember/test-helpers';
+import { module, test } from 'qunit';
+import Foo from 'v2-app/components/foo';
+import { setupRenderingTest } from 'ember-qunit';
+
+module('Integration | Component | Foo', function (hooks) {
+  setupRenderingTest(hooks);
+
+  test('it renders', async function (assert) {
+    await render(<template><Foo /></template>);
+
+    assert.dom().hasText('');
+
+    await render(
+      <template>
+        <Foo>
+          template block text
+        </Foo>
+      </template>
+    );
+
+    assert.dom().hasText('template block text');
+  });
+});
+"
+`;
+
+exports[`package-type: v2-app > generator: component > args: --log --nested --test 1`] = `
+"[log] <template>{{yield}}</template>
+
+[log] import { render } from '@ember/test-helpers';
+import { module, test } from 'qunit';
+import Foo from 'v2-app/components/foo';
+import { setupRenderingTest } from 'ember-qunit';
+
+module('Integration | Component | Foo', function (hooks) {
+  setupRenderingTest(hooks);
+
+  test('it renders', async function (assert) {
+    await render(<template><Foo /></template>);
+
+    assert.dom().hasText('');
+
+    await render(
+      <template>
+        <Foo>
+          template block text
+        </Foo>
+      </template>
+    );
+
+    assert.dom().hasText('template block text');
+  });
+});
+"
+`;
+
+exports[`package-type: v2-app > generator: component > args: --log --nested --typescript 1`] = `
+"[log] import type { TOC } from '@ember/component/template-only';
+
+export interface FooSignature {
+  Args: {};
+  Blocks: {
+    default: [];
+  };
+  Element: null;
+}
+
+const Foo: TOC<FooSignature> = <template>{{yield}}</template>;
+
+export default Foo;
+"
+`;
+
+exports[`package-type: v2-app > generator: component > args: --log --nested 1`] = `
+"[log] <template>{{yield}}</template>
+"
+`;
+
+exports[`package-type: v2-app > generator: component > args: --log --test --typescript 1`] = `
+"[log] import type { TOC } from '@ember/component/template-only';
+
+export interface FooSignature {
+  Args: {};
+  Blocks: {
+    default: [];
+  };
+  Element: null;
+}
+
+const Foo: TOC<FooSignature> = <template>{{yield}}</template>;
+
+export default Foo;
+
+[log] import { render } from '@ember/test-helpers';
+import { module, test } from 'qunit';
+import Foo from 'v2-app/components/foo';
+import { setupRenderingTest } from 'ember-qunit';
+
+module('Integration | Component | Foo', function (hooks) {
+  setupRenderingTest(hooks);
+
+  test('it renders', async function (assert) {
+    await render(<template><Foo /></template>);
+
+    assert.dom().hasText('');
+
+    await render(
+      <template>
+        <Foo>
+          template block text
+        </Foo>
+      </template>
+    );
+
+    assert.dom().hasText('template block text');
+  });
+});
+"
+`;
+
+exports[`package-type: v2-app > generator: component > args: --log --test 1`] = `
+"[log] <template>{{yield}}</template>
+
+[log] import { render } from '@ember/test-helpers';
+import { module, test } from 'qunit';
+import Foo from 'v2-app/components/foo';
+import { setupRenderingTest } from 'ember-qunit';
+
+module('Integration | Component | Foo', function (hooks) {
+  setupRenderingTest(hooks);
+
+  test('it renders', async function (assert) {
+    await render(<template><Foo /></template>);
+
+    assert.dom().hasText('');
+
+    await render(
+      <template>
+        <Foo>
+          template block text
+        </Foo>
+      </template>
+    );
+
+    assert.dom().hasText('template block text');
+  });
+});
+"
+`;
+
+exports[`package-type: v2-app > generator: component > args: --log --typescript 1`] = `
+"[log] import type { TOC } from '@ember/component/template-only';
+
+export interface FooSignature {
+  Args: {};
+  Blocks: {
+    default: [];
+  };
+  Element: null;
+}
+
+const Foo: TOC<FooSignature> = <template>{{yield}}</template>;
+
+export default Foo;
+"
+`;
+
+exports[`package-type: v2-app > generator: component > args: --log 1`] = `
+"[log] <template>{{yield}}</template>
+"
+`;
+
+exports[`package-type: v2-app > generator: component > args: --namedExport --nested --test --typescript 1`] = `
+"[success] Generated component \`foo\` at \`app/components/foo/index.gts\`.
+[success] Generated component-test \`foo\` at \`tests/integration/components/foo-test.gts\`."
+`;
+
+exports[`package-type: v2-app > generator: component > args: --namedExport --nested --test 1`] = `
+"[success] Generated component \`foo\` at \`app/components/foo/index.gjs\`.
+[success] Generated component-test \`foo\` at \`tests/integration/components/foo-test.gjs\`."
+`;
+
+exports[`package-type: v2-app > generator: component > args: --namedExport --nested --typescript 1`] = `"[success] Generated component \`foo\` at \`app/components/foo/index.gts\`."`;
+
+exports[`package-type: v2-app > generator: component > args: --namedExport --nested 1`] = `"[success] Generated component \`foo\` at \`app/components/foo/index.gjs\`."`;
+
+exports[`package-type: v2-app > generator: component > args: --namedExport --test --typescript 1`] = `
+"[success] Generated component \`foo\` at \`app/components/foo.gts\`.
+[success] Generated component-test \`foo\` at \`tests/integration/components/foo-test.gts\`."
+`;
+
+exports[`package-type: v2-app > generator: component > args: --namedExport --test 1`] = `
+"[success] Generated component \`foo\` at \`app/components/foo.gjs\`.
+[success] Generated component-test \`foo\` at \`tests/integration/components/foo-test.gjs\`."
+`;
+
+exports[`package-type: v2-app > generator: component > args: --namedExport --typescript 1`] = `"[success] Generated component \`foo\` at \`app/components/foo.gts\`."`;
+
+exports[`package-type: v2-app > generator: component > args: --namedExport 1`] = `"[success] Generated component \`foo\` at \`app/components/foo.gjs\`."`;
+
+exports[`package-type: v2-app > generator: component > args: --nested --test --typescript 1`] = `
+"[success] Generated component \`foo\` at \`app/components/foo/index.gts\`.
+[success] Generated component-test \`foo\` at \`tests/integration/components/foo-test.gts\`."
+`;
+
+exports[`package-type: v2-app > generator: component > args: --nested --test 1`] = `
+"[success] Generated component \`foo\` at \`app/components/foo/index.gjs\`.
+[success] Generated component-test \`foo\` at \`tests/integration/components/foo-test.gjs\`."
+`;
+
+exports[`package-type: v2-app > generator: component > args: --nested --typescript 1`] = `"[success] Generated component \`foo\` at \`app/components/foo/index.gts\`."`;
+
+exports[`package-type: v2-app > generator: component > args: --nested 1`] = `"[success] Generated component \`foo\` at \`app/components/foo/index.gjs\`."`;
+
+exports[`package-type: v2-app > generator: component > args: --test --typescript 1`] = `
+"[success] Generated component \`foo\` at \`app/components/foo.gts\`.
+[success] Generated component-test \`foo\` at \`tests/integration/components/foo-test.gts\`."
+`;
+
+exports[`package-type: v2-app > generator: component > args: --test 1`] = `
+"[success] Generated component \`foo\` at \`app/components/foo.gjs\`.
+[success] Generated component-test \`foo\` at \`tests/integration/components/foo-test.gjs\`."
+`;
+
+exports[`package-type: v2-app > generator: component > args: --typescript 1`] = `"[success] Generated component \`foo\` at \`app/components/foo.gts\`."`;
+
+exports[`package-type: v2-app > generator: component-test > args: --log --typescript 1`] = `
+"[log] import { render } from '@ember/test-helpers';
+import { module, test } from 'qunit';
+import Foo from 'v2-app/components/foo';
+import { setupRenderingTest } from 'ember-qunit';
+
+module('Integration | Component | Foo', function (hooks) {
+  setupRenderingTest(hooks);
+
+  test('it renders', async function (assert) {
+    await render(<template><Foo /></template>);
+
+    assert.dom().hasText('');
+
+    await render(
+      <template>
+        <Foo>
+          template block text
+        </Foo>
+      </template>
+    );
+
+    assert.dom().hasText('template block text');
+  });
+});
+"
+`;
+
+exports[`package-type: v2-app > generator: component-test > args: --log 1`] = `
+"[log] import { render } from '@ember/test-helpers';
+import { module, test } from 'qunit';
+import Foo from 'v2-app/components/foo';
+import { setupRenderingTest } from 'ember-qunit';
+
+module('Integration | Component | Foo', function (hooks) {
+  setupRenderingTest(hooks);
+
+  test('it renders', async function (assert) {
+    await render(<template><Foo /></template>);
+
+    assert.dom().hasText('');
+
+    await render(
+      <template>
+        <Foo>
+          template block text
+        </Foo>
+      </template>
+    );
+
+    assert.dom().hasText('template block text');
+  });
+});
+"
+`;
+
+exports[`package-type: v2-app > generator: component-test > args: --typescript 1`] = `"[success] Generated component-test \`foo\` at \`tests/integration/components/foo-test.gts\`."`;
+
+exports[`package-type: v2-app > generator: controller > args: --log --test --typescript 1`] = `
+"[log] import Controller from '@ember/controller';
+
+export default class FooController extends Controller {}
+
+[log] import { module, test } from 'qunit';
+import { setupTest } from 'ember-qunit';
+
+module('Unit | Controller | Foo', function (hooks) {
+  setupTest(hooks);
+
+  test('it exists', function (assert) {
+    const controller = this.owner.lookup('controller:foo');
+
+    assert.ok(controller);
+  });
+});
+"
+`;
+
+exports[`package-type: v2-app > generator: controller > args: --log --test 1`] = `
+"[log] import Controller from '@ember/controller';
+
+export default class FooController extends Controller {}
+
+[log] import { module, test } from 'qunit';
+import { setupTest } from 'ember-qunit';
+
+module('Unit | Controller | Foo', function (hooks) {
+  setupTest(hooks);
+
+  test('it exists', function (assert) {
+    const controller = this.owner.lookup('controller:foo');
+
+    assert.ok(controller);
+  });
+});
+"
+`;
+
+exports[`package-type: v2-app > generator: controller > args: --log --typescript 1`] = `
+"[log] import Controller from '@ember/controller';
+
+export default class FooController extends Controller {}
+"
+`;
+
+exports[`package-type: v2-app > generator: controller > args: --log 1`] = `
+"[log] import Controller from '@ember/controller';
+
+export default class FooController extends Controller {}
+"
+`;
+
+exports[`package-type: v2-app > generator: controller > args: --test --typescript 1`] = `
+"[success] Generated controller \`foo\` at \`app/controllers/foo.ts\`.
+[success] Generated controller-test \`foo\` at \`tests/unit/controllers/foo-test.ts\`."
+`;
+
+exports[`package-type: v2-app > generator: controller > args: --test 1`] = `
+"[success] Generated controller \`foo\` at \`app/controllers/foo.js\`.
+[success] Generated controller-test \`foo\` at \`tests/unit/controllers/foo-test.js\`."
+`;
+
+exports[`package-type: v2-app > generator: controller > args: --typescript 1`] = `"[success] Generated controller \`foo\` at \`app/controllers/foo.ts\`."`;
+
+exports[`package-type: v2-app > generator: controller-test > args: --log --typescript 1`] = `
+"[log] import { module, test } from 'qunit';
+import { setupTest } from 'ember-qunit';
+
+module('Unit | Controller | Foo', function (hooks) {
+  setupTest(hooks);
+
+  test('it exists', function (assert) {
+    const controller = this.owner.lookup('controller:foo');
+
+    assert.ok(controller);
+  });
+});
+"
+`;
+
+exports[`package-type: v2-app > generator: controller-test > args: --log 1`] = `
+"[log] import { module, test } from 'qunit';
+import { setupTest } from 'ember-qunit';
+
+module('Unit | Controller | Foo', function (hooks) {
+  setupTest(hooks);
+
+  test('it exists', function (assert) {
+    const controller = this.owner.lookup('controller:foo');
+
+    assert.ok(controller);
+  });
+});
+"
+`;
+
+exports[`package-type: v2-app > generator: controller-test > args: --typescript 1`] = `"[success] Generated controller-test \`foo\` at \`tests/unit/controllers/foo-test.ts\`."`;
+
+exports[`package-type: v2-app > generator: helper > args: --classBased --log --namedExport --test --typescript 1`] = `
+"[log] import Helper from '@ember/component/helper';
+
+type Named = {};
+type Positional = [];
+type Return = Positional;
+
+export interface FooSignature {
+  Args: {
+    Named: Named;
+    Positional: Positional;
+  };
+  Return: Return;
+}
+
+export class foo extends Helper<FooSignature> {
+  compute(positional: Positional, named: Named): Return {
+    return positional;
+  }
+}
+
+[log] import { render } from '@ember/test-helpers';
+import { module, test } from 'qunit';
+import foo from 'v2-app/helpers/foo';
+import { setupRenderingTest } from 'ember-qunit';
+
+module('Integration | Helper | foo', function (hooks) {
+  setupRenderingTest(hooks);
+
+  test('it renders', async function (assert) {
+    const inputValue = '1234';
+
+    await render(<template>{{foo inputValue}}</template>);
+
+    assert.dom().hasText('1234');
+  });
+});
+"
+`;
+
+exports[`package-type: v2-app > generator: helper > args: --classBased --log --namedExport --test 1`] = `
+"[log] import Helper from '@ember/component/helper';
+
+export class foo extends Helper {
+  compute(positional, named) {
+    return positional;
+  }
+}
+
+[log] import { render } from '@ember/test-helpers';
+import { module, test } from 'qunit';
+import foo from 'v2-app/helpers/foo';
+import { setupRenderingTest } from 'ember-qunit';
+
+module('Integration | Helper | foo', function (hooks) {
+  setupRenderingTest(hooks);
+
+  test('it renders', async function (assert) {
+    const inputValue = '1234';
+
+    await render(<template>{{foo inputValue}}</template>);
+
+    assert.dom().hasText('1234');
+  });
+});
+"
+`;
+
+exports[`package-type: v2-app > generator: helper > args: --classBased --log --namedExport --typescript 1`] = `
+"[log] import Helper from '@ember/component/helper';
+
+type Named = {};
+type Positional = [];
+type Return = Positional;
+
+export interface FooSignature {
+  Args: {
+    Named: Named;
+    Positional: Positional;
+  };
+  Return: Return;
+}
+
+export class foo extends Helper<FooSignature> {
+  compute(positional: Positional, named: Named): Return {
+    return positional;
+  }
+}
+"
+`;
+
+exports[`package-type: v2-app > generator: helper > args: --classBased --log --namedExport 1`] = `
+"[log] import Helper from '@ember/component/helper';
+
+export class foo extends Helper {
+  compute(positional, named) {
+    return positional;
+  }
+}
+"
+`;
+
+exports[`package-type: v2-app > generator: helper > args: --classBased --log --test --typescript 1`] = `
+"[log] import Helper from '@ember/component/helper';
+
+type Named = {};
+type Positional = [];
+type Return = Positional;
+
+export interface FooSignature {
+  Args: {
+    Named: Named;
+    Positional: Positional;
+  };
+  Return: Return;
+}
+
+export default class foo extends Helper<FooSignature> {
+  compute(positional: Positional, named: Named): Return {
+    return positional;
+  }
+}
+
+[log] import { render } from '@ember/test-helpers';
+import { module, test } from 'qunit';
+import foo from 'v2-app/helpers/foo';
+import { setupRenderingTest } from 'ember-qunit';
+
+module('Integration | Helper | foo', function (hooks) {
+  setupRenderingTest(hooks);
+
+  test('it renders', async function (assert) {
+    const inputValue = '1234';
+
+    await render(<template>{{foo inputValue}}</template>);
+
+    assert.dom().hasText('1234');
+  });
+});
+"
+`;
+
+exports[`package-type: v2-app > generator: helper > args: --classBased --log --test 1`] = `
+"[log] import Helper from '@ember/component/helper';
+
+export default class foo extends Helper {
+  compute(positional, named) {
+    return positional;
+  }
+}
+
+[log] import { render } from '@ember/test-helpers';
+import { module, test } from 'qunit';
+import foo from 'v2-app/helpers/foo';
+import { setupRenderingTest } from 'ember-qunit';
+
+module('Integration | Helper | foo', function (hooks) {
+  setupRenderingTest(hooks);
+
+  test('it renders', async function (assert) {
+    const inputValue = '1234';
+
+    await render(<template>{{foo inputValue}}</template>);
+
+    assert.dom().hasText('1234');
+  });
+});
+"
+`;
+
+exports[`package-type: v2-app > generator: helper > args: --classBased --log --typescript 1`] = `
+"[log] import Helper from '@ember/component/helper';
+
+type Named = {};
+type Positional = [];
+type Return = Positional;
+
+export interface FooSignature {
+  Args: {
+    Named: Named;
+    Positional: Positional;
+  };
+  Return: Return;
+}
+
+export default class foo extends Helper<FooSignature> {
+  compute(positional: Positional, named: Named): Return {
+    return positional;
+  }
+}
+"
+`;
+
+exports[`package-type: v2-app > generator: helper > args: --classBased --log 1`] = `
+"[log] import Helper from '@ember/component/helper';
+
+export default class foo extends Helper {
+  compute(positional, named) {
+    return positional;
+  }
+}
+"
+`;
+
+exports[`package-type: v2-app > generator: helper > args: --classBased --namedExport --test --typescript 1`] = `
+"[success] Generated helper \`foo\` at \`app/helpers/foo.ts\`.
+[success] Generated helper-test \`foo\` at \`tests/integration/helpers/foo-test.gts\`."
+`;
+
+exports[`package-type: v2-app > generator: helper > args: --classBased --namedExport --test 1`] = `
+"[success] Generated helper \`foo\` at \`app/helpers/foo.js\`.
+[success] Generated helper-test \`foo\` at \`tests/integration/helpers/foo-test.gjs\`."
+`;
+
+exports[`package-type: v2-app > generator: helper > args: --classBased --namedExport --typescript 1`] = `"[success] Generated helper \`foo\` at \`app/helpers/foo.ts\`."`;
+
+exports[`package-type: v2-app > generator: helper > args: --classBased --namedExport 1`] = `"[success] Generated helper \`foo\` at \`app/helpers/foo.js\`."`;
+
+exports[`package-type: v2-app > generator: helper > args: --classBased --test --typescript 1`] = `
+"[success] Generated helper \`foo\` at \`app/helpers/foo.ts\`.
+[success] Generated helper-test \`foo\` at \`tests/integration/helpers/foo-test.gts\`."
+`;
+
+exports[`package-type: v2-app > generator: helper > args: --classBased --test 1`] = `
+"[success] Generated helper \`foo\` at \`app/helpers/foo.js\`.
+[success] Generated helper-test \`foo\` at \`tests/integration/helpers/foo-test.gjs\`."
+`;
+
+exports[`package-type: v2-app > generator: helper > args: --classBased --typescript 1`] = `"[success] Generated helper \`foo\` at \`app/helpers/foo.ts\`."`;
+
+exports[`package-type: v2-app > generator: helper > args: --classBased 1`] = `"[success] Generated helper \`foo\` at \`app/helpers/foo.js\`."`;
+
+exports[`package-type: v2-app > generator: helper > args: --log --namedExport --test --typescript 1`] = `
+"[log] export function foo(positional, named) {
+  return positional;
+}
+
+[log] import { render } from '@ember/test-helpers';
+import { module, test } from 'qunit';
+import foo from 'v2-app/helpers/foo';
+import { setupRenderingTest } from 'ember-qunit';
+
+module('Integration | Helper | foo', function (hooks) {
+  setupRenderingTest(hooks);
+
+  test('it renders', async function (assert) {
+    const inputValue = '1234';
+
+    await render(<template>{{foo inputValue}}</template>);
+
+    assert.dom().hasText('1234');
+  });
+});
+"
+`;
+
+exports[`package-type: v2-app > generator: helper > args: --log --namedExport --test 1`] = `
+"[log] export function foo(positional, named) {
+  return positional;
+}
+
+[log] import { render } from '@ember/test-helpers';
+import { module, test } from 'qunit';
+import foo from 'v2-app/helpers/foo';
+import { setupRenderingTest } from 'ember-qunit';
+
+module('Integration | Helper | foo', function (hooks) {
+  setupRenderingTest(hooks);
+
+  test('it renders', async function (assert) {
+    const inputValue = '1234';
+
+    await render(<template>{{foo inputValue}}</template>);
+
+    assert.dom().hasText('1234');
+  });
+});
+"
+`;
+
+exports[`package-type: v2-app > generator: helper > args: --log --namedExport --typescript 1`] = `
+"[log] export function foo(positional, named) {
+  return positional;
+}
+"
+`;
+
+exports[`package-type: v2-app > generator: helper > args: --log --namedExport 1`] = `
+"[log] export function foo(positional, named) {
+  return positional;
+}
+"
+`;
+
+exports[`package-type: v2-app > generator: helper > args: --log --test --typescript 1`] = `
+"[log] export default function foo(positional, named) {
+  return positional;
+}
+
+[log] import { render } from '@ember/test-helpers';
+import { module, test } from 'qunit';
+import foo from 'v2-app/helpers/foo';
+import { setupRenderingTest } from 'ember-qunit';
+
+module('Integration | Helper | foo', function (hooks) {
+  setupRenderingTest(hooks);
+
+  test('it renders', async function (assert) {
+    const inputValue = '1234';
+
+    await render(<template>{{foo inputValue}}</template>);
+
+    assert.dom().hasText('1234');
+  });
+});
+"
+`;
+
+exports[`package-type: v2-app > generator: helper > args: --log --test 1`] = `
+"[log] export default function foo(positional, named) {
+  return positional;
+}
+
+[log] import { render } from '@ember/test-helpers';
+import { module, test } from 'qunit';
+import foo from 'v2-app/helpers/foo';
+import { setupRenderingTest } from 'ember-qunit';
+
+module('Integration | Helper | foo', function (hooks) {
+  setupRenderingTest(hooks);
+
+  test('it renders', async function (assert) {
+    const inputValue = '1234';
+
+    await render(<template>{{foo inputValue}}</template>);
+
+    assert.dom().hasText('1234');
+  });
+});
+"
+`;
+
+exports[`package-type: v2-app > generator: helper > args: --log --typescript 1`] = `
+"[log] export default function foo(positional, named) {
+  return positional;
+}
+"
+`;
+
+exports[`package-type: v2-app > generator: helper > args: --log 1`] = `
+"[log] export default function foo(positional, named) {
+  return positional;
+}
+"
+`;
+
+exports[`package-type: v2-app > generator: helper > args: --namedExport --test --typescript 1`] = `
+"[success] Generated helper \`foo\` at \`app/helpers/foo.ts\`.
+[success] Generated helper-test \`foo\` at \`tests/integration/helpers/foo-test.gts\`."
+`;
+
+exports[`package-type: v2-app > generator: helper > args: --namedExport --test 1`] = `
+"[success] Generated helper \`foo\` at \`app/helpers/foo.js\`.
+[success] Generated helper-test \`foo\` at \`tests/integration/helpers/foo-test.gjs\`."
+`;
+
+exports[`package-type: v2-app > generator: helper > args: --namedExport --typescript 1`] = `"[success] Generated helper \`foo\` at \`app/helpers/foo.ts\`."`;
+
+exports[`package-type: v2-app > generator: helper > args: --namedExport 1`] = `"[success] Generated helper \`foo\` at \`app/helpers/foo.js\`."`;
+
+exports[`package-type: v2-app > generator: helper > args: --test --typescript 1`] = `
+"[success] Generated helper \`foo\` at \`app/helpers/foo.ts\`.
+[success] Generated helper-test \`foo\` at \`tests/integration/helpers/foo-test.gts\`."
+`;
+
+exports[`package-type: v2-app > generator: helper > args: --test 1`] = `
+"[success] Generated helper \`foo\` at \`app/helpers/foo.js\`.
+[success] Generated helper-test \`foo\` at \`tests/integration/helpers/foo-test.gjs\`."
+`;
+
+exports[`package-type: v2-app > generator: helper > args: --typescript 1`] = `"[success] Generated helper \`foo\` at \`app/helpers/foo.ts\`."`;
+
+exports[`package-type: v2-app > generator: helper-test > args: --log --typescript 1`] = `
+"[log] import { render } from '@ember/test-helpers';
+import { module, test } from 'qunit';
+import foo from 'v2-app/helpers/foo';
+import { setupRenderingTest } from 'ember-qunit';
+
+module('Integration | Helper | foo', function (hooks) {
+  setupRenderingTest(hooks);
+
+  test('it renders', async function (assert) {
+    const inputValue = '1234';
+
+    await render(<template>{{foo inputValue}}</template>);
+
+    assert.dom().hasText('1234');
+  });
+});
+"
+`;
+
+exports[`package-type: v2-app > generator: helper-test > args: --log 1`] = `
+"[log] import { render } from '@ember/test-helpers';
+import { module, test } from 'qunit';
+import foo from 'v2-app/helpers/foo';
+import { setupRenderingTest } from 'ember-qunit';
+
+module('Integration | Helper | foo', function (hooks) {
+  setupRenderingTest(hooks);
+
+  test('it renders', async function (assert) {
+    const inputValue = '1234';
+
+    await render(<template>{{foo inputValue}}</template>);
+
+    assert.dom().hasText('1234');
+  });
+});
+"
+`;
+
+exports[`package-type: v2-app > generator: helper-test > args: --typescript 1`] = `"[success] Generated helper-test \`foo\` at \`tests/integration/helpers/foo-test.gts\`."`;
+
+exports[`package-type: v2-app > generator: modifier > args: --classBased --log --namedExport --test --typescript 1`] = `
+"[log] import Modifier from 'ember-modifier';
+
+type Named = {};
+type Positional = [];
+type Element = null;
+
+export interface FooSignature {
+  Args: {
+    Named: Named;
+    Positional: Positional;
+  };
+  Element: Element;
+}
+
+export class foo extends Modifier<FooSignature> {
+  modify(element: Element, positional: Positional, named: Named) {}
+}
+
+[log] import { render } from '@ember/test-helpers';
+import { module, test } from 'qunit';
+import foo from 'v2-app/modifiers/foo';
+import { setupRenderingTest } from 'ember-qunit';
+
+module('Integration | Modifier | foo', function (hooks) {
+  setupRenderingTest(hooks);
+
+  test('it renders', async function (assert) {
+    await render(
+      <template>
+        <div {{foo}}></div>
+      </template>
+    );
+
+    assert.ok(true);
+  });
+});
+"
+`;
+
+exports[`package-type: v2-app > generator: modifier > args: --classBased --log --namedExport --test 1`] = `
+"[log] import Modifier from 'ember-modifier';
+
+export class foo extends Modifier {
+  modify(element, positional, named) {}
+}
+
+[log] import { render } from '@ember/test-helpers';
+import { module, test } from 'qunit';
+import foo from 'v2-app/modifiers/foo';
+import { setupRenderingTest } from 'ember-qunit';
+
+module('Integration | Modifier | foo', function (hooks) {
+  setupRenderingTest(hooks);
+
+  test('it renders', async function (assert) {
+    await render(
+      <template>
+        <div {{foo}}></div>
+      </template>
+    );
+
+    assert.ok(true);
+  });
+});
+"
+`;
+
+exports[`package-type: v2-app > generator: modifier > args: --classBased --log --namedExport --typescript 1`] = `
+"[log] import Modifier from 'ember-modifier';
+
+type Named = {};
+type Positional = [];
+type Element = null;
+
+export interface FooSignature {
+  Args: {
+    Named: Named;
+    Positional: Positional;
+  };
+  Element: Element;
+}
+
+export class foo extends Modifier<FooSignature> {
+  modify(element: Element, positional: Positional, named: Named) {}
+}
+"
+`;
+
+exports[`package-type: v2-app > generator: modifier > args: --classBased --log --namedExport 1`] = `
+"[log] import Modifier from 'ember-modifier';
+
+export class foo extends Modifier {
+  modify(element, positional, named) {}
+}
+"
+`;
+
+exports[`package-type: v2-app > generator: modifier > args: --classBased --log --test --typescript 1`] = `
+"[log] import Modifier from 'ember-modifier';
+
+type Named = {};
+type Positional = [];
+type Element = null;
+
+export interface FooSignature {
+  Args: {
+    Named: Named;
+    Positional: Positional;
+  };
+  Element: Element;
+}
+
+export default class foo extends Modifier<FooSignature> {
+  modify(element: Element, positional: Positional, named: Named) {}
+}
+
+[log] import { render } from '@ember/test-helpers';
+import { module, test } from 'qunit';
+import foo from 'v2-app/modifiers/foo';
+import { setupRenderingTest } from 'ember-qunit';
+
+module('Integration | Modifier | foo', function (hooks) {
+  setupRenderingTest(hooks);
+
+  test('it renders', async function (assert) {
+    await render(
+      <template>
+        <div {{foo}}></div>
+      </template>
+    );
+
+    assert.ok(true);
+  });
+});
+"
+`;
+
+exports[`package-type: v2-app > generator: modifier > args: --classBased --log --test 1`] = `
+"[log] import Modifier from 'ember-modifier';
+
+export default class foo extends Modifier {
+  modify(element, positional, named) {}
+}
+
+[log] import { render } from '@ember/test-helpers';
+import { module, test } from 'qunit';
+import foo from 'v2-app/modifiers/foo';
+import { setupRenderingTest } from 'ember-qunit';
+
+module('Integration | Modifier | foo', function (hooks) {
+  setupRenderingTest(hooks);
+
+  test('it renders', async function (assert) {
+    await render(
+      <template>
+        <div {{foo}}></div>
+      </template>
+    );
+
+    assert.ok(true);
+  });
+});
+"
+`;
+
+exports[`package-type: v2-app > generator: modifier > args: --classBased --log --typescript 1`] = `
+"[log] import Modifier from 'ember-modifier';
+
+type Named = {};
+type Positional = [];
+type Element = null;
+
+export interface FooSignature {
+  Args: {
+    Named: Named;
+    Positional: Positional;
+  };
+  Element: Element;
+}
+
+export default class foo extends Modifier<FooSignature> {
+  modify(element: Element, positional: Positional, named: Named) {}
+}
+"
+`;
+
+exports[`package-type: v2-app > generator: modifier > args: --classBased --log 1`] = `
+"[log] import Modifier from 'ember-modifier';
+
+export default class foo extends Modifier {
+  modify(element, positional, named) {}
+}
+"
+`;
+
+exports[`package-type: v2-app > generator: modifier > args: --classBased --namedExport --test --typescript 1`] = `
+"[success] Generated modifier \`foo\` at \`app/modifiers/foo.ts\`.
+[success] Generated modifier-test \`foo\` at \`tests/integration/modifiers/foo-test.gts\`."
+`;
+
+exports[`package-type: v2-app > generator: modifier > args: --classBased --namedExport --test 1`] = `
+"[success] Generated modifier \`foo\` at \`app/modifiers/foo.js\`.
+[success] Generated modifier-test \`foo\` at \`tests/integration/modifiers/foo-test.gjs\`."
+`;
+
+exports[`package-type: v2-app > generator: modifier > args: --classBased --namedExport --typescript 1`] = `"[success] Generated modifier \`foo\` at \`app/modifiers/foo.ts\`."`;
+
+exports[`package-type: v2-app > generator: modifier > args: --classBased --namedExport 1`] = `"[success] Generated modifier \`foo\` at \`app/modifiers/foo.js\`."`;
+
+exports[`package-type: v2-app > generator: modifier > args: --classBased --test --typescript 1`] = `
+"[success] Generated modifier \`foo\` at \`app/modifiers/foo.ts\`.
+[success] Generated modifier-test \`foo\` at \`tests/integration/modifiers/foo-test.gts\`."
+`;
+
+exports[`package-type: v2-app > generator: modifier > args: --classBased --test 1`] = `
+"[success] Generated modifier \`foo\` at \`app/modifiers/foo.js\`.
+[success] Generated modifier-test \`foo\` at \`tests/integration/modifiers/foo-test.gjs\`."
+`;
+
+exports[`package-type: v2-app > generator: modifier > args: --classBased --typescript 1`] = `"[success] Generated modifier \`foo\` at \`app/modifiers/foo.ts\`."`;
+
+exports[`package-type: v2-app > generator: modifier > args: --classBased 1`] = `"[success] Generated modifier \`foo\` at \`app/modifiers/foo.js\`."`;
+
+exports[`package-type: v2-app > generator: modifier > args: --log --namedExport --test --typescript 1`] = `
+"[log] import { modifier } from 'ember-modifier';
+
+export interface FooSignature {
+  Args: {
+    Named: {};
+    Positional: [];
+  };
+  Element: null;
+}
+
+export const foo = modifier<FooSignature>(function foo(element, positional, named) {});
+
+[log] import { render } from '@ember/test-helpers';
+import { module, test } from 'qunit';
+import foo from 'v2-app/modifiers/foo';
+import { setupRenderingTest } from 'ember-qunit';
+
+module('Integration | Modifier | foo', function (hooks) {
+  setupRenderingTest(hooks);
+
+  test('it renders', async function (assert) {
+    await render(
+      <template>
+        <div {{foo}}></div>
+      </template>
+    );
+
+    assert.ok(true);
+  });
+});
+"
+`;
+
+exports[`package-type: v2-app > generator: modifier > args: --log --namedExport --test 1`] = `
+"[log] import { modifier } from 'ember-modifier';
+
+export const foo = modifier(function foo(element, positional, named) {});
+
+[log] import { render } from '@ember/test-helpers';
+import { module, test } from 'qunit';
+import foo from 'v2-app/modifiers/foo';
+import { setupRenderingTest } from 'ember-qunit';
+
+module('Integration | Modifier | foo', function (hooks) {
+  setupRenderingTest(hooks);
+
+  test('it renders', async function (assert) {
+    await render(
+      <template>
+        <div {{foo}}></div>
+      </template>
+    );
+
+    assert.ok(true);
+  });
+});
+"
+`;
+
+exports[`package-type: v2-app > generator: modifier > args: --log --namedExport --typescript 1`] = `
+"[log] import { modifier } from 'ember-modifier';
+
+export interface FooSignature {
+  Args: {
+    Named: {};
+    Positional: [];
+  };
+  Element: null;
+}
+
+export const foo = modifier<FooSignature>(function foo(element, positional, named) {});
+"
+`;
+
+exports[`package-type: v2-app > generator: modifier > args: --log --namedExport 1`] = `
+"[log] import { modifier } from 'ember-modifier';
+
+export const foo = modifier(function foo(element, positional, named) {});
+"
+`;
+
+exports[`package-type: v2-app > generator: modifier > args: --log --test --typescript 1`] = `
+"[log] import { modifier } from 'ember-modifier';
+
+export interface FooSignature {
+  Args: {
+    Named: {};
+    Positional: [];
+  };
+  Element: null;
+}
+
+export default modifier<FooSignature>(function foo(element, positional, named) {});
+
+[log] import { render } from '@ember/test-helpers';
+import { module, test } from 'qunit';
+import foo from 'v2-app/modifiers/foo';
+import { setupRenderingTest } from 'ember-qunit';
+
+module('Integration | Modifier | foo', function (hooks) {
+  setupRenderingTest(hooks);
+
+  test('it renders', async function (assert) {
+    await render(
+      <template>
+        <div {{foo}}></div>
+      </template>
+    );
+
+    assert.ok(true);
+  });
+});
+"
+`;
+
+exports[`package-type: v2-app > generator: modifier > args: --log --test 1`] = `
+"[log] import { modifier } from 'ember-modifier';
+
+export default modifier(function foo(element, positional, named) {});
+
+[log] import { render } from '@ember/test-helpers';
+import { module, test } from 'qunit';
+import foo from 'v2-app/modifiers/foo';
+import { setupRenderingTest } from 'ember-qunit';
+
+module('Integration | Modifier | foo', function (hooks) {
+  setupRenderingTest(hooks);
+
+  test('it renders', async function (assert) {
+    await render(
+      <template>
+        <div {{foo}}></div>
+      </template>
+    );
+
+    assert.ok(true);
+  });
+});
+"
+`;
+
+exports[`package-type: v2-app > generator: modifier > args: --log --typescript 1`] = `
+"[log] import { modifier } from 'ember-modifier';
+
+export interface FooSignature {
+  Args: {
+    Named: {};
+    Positional: [];
+  };
+  Element: null;
+}
+
+export default modifier<FooSignature>(function foo(element, positional, named) {});
+"
+`;
+
+exports[`package-type: v2-app > generator: modifier > args: --log 1`] = `
+"[log] import { modifier } from 'ember-modifier';
+
+export default modifier(function foo(element, positional, named) {});
+"
+`;
+
+exports[`package-type: v2-app > generator: modifier > args: --namedExport --test --typescript 1`] = `
+"[success] Generated modifier \`foo\` at \`app/modifiers/foo.ts\`.
+[success] Generated modifier-test \`foo\` at \`tests/integration/modifiers/foo-test.gts\`."
+`;
+
+exports[`package-type: v2-app > generator: modifier > args: --namedExport --test 1`] = `
+"[success] Generated modifier \`foo\` at \`app/modifiers/foo.js\`.
+[success] Generated modifier-test \`foo\` at \`tests/integration/modifiers/foo-test.gjs\`."
+`;
+
+exports[`package-type: v2-app > generator: modifier > args: --namedExport --typescript 1`] = `"[success] Generated modifier \`foo\` at \`app/modifiers/foo.ts\`."`;
+
+exports[`package-type: v2-app > generator: modifier > args: --namedExport 1`] = `"[success] Generated modifier \`foo\` at \`app/modifiers/foo.js\`."`;
+
+exports[`package-type: v2-app > generator: modifier > args: --test --typescript 1`] = `
+"[success] Generated modifier \`foo\` at \`app/modifiers/foo.ts\`.
+[success] Generated modifier-test \`foo\` at \`tests/integration/modifiers/foo-test.gts\`."
+`;
+
+exports[`package-type: v2-app > generator: modifier > args: --test 1`] = `
+"[success] Generated modifier \`foo\` at \`app/modifiers/foo.js\`.
+[success] Generated modifier-test \`foo\` at \`tests/integration/modifiers/foo-test.gjs\`."
+`;
+
+exports[`package-type: v2-app > generator: modifier > args: --typescript 1`] = `"[success] Generated modifier \`foo\` at \`app/modifiers/foo.ts\`."`;
+
+exports[`package-type: v2-app > generator: modifier-test > args: --log --typescript 1`] = `
+"[log] import { render } from '@ember/test-helpers';
+import { module, test } from 'qunit';
+import foo from 'v2-app/modifiers/foo';
+import { setupRenderingTest } from 'ember-qunit';
+
+module('Integration | Modifier | foo', function (hooks) {
+  setupRenderingTest(hooks);
+
+  test('it renders', async function (assert) {
+    await render(
+      <template>
+        <div {{foo}}></div>
+      </template>
+    );
+
+    assert.ok(true);
+  });
+});
+"
+`;
+
+exports[`package-type: v2-app > generator: modifier-test > args: --log 1`] = `
+"[log] import { render } from '@ember/test-helpers';
+import { module, test } from 'qunit';
+import foo from 'v2-app/modifiers/foo';
+import { setupRenderingTest } from 'ember-qunit';
+
+module('Integration | Modifier | foo', function (hooks) {
+  setupRenderingTest(hooks);
+
+  test('it renders', async function (assert) {
+    await render(
+      <template>
+        <div {{foo}}></div>
+      </template>
+    );
+
+    assert.ok(true);
+  });
+});
+"
+`;
+
+exports[`package-type: v2-app > generator: modifier-test > args: --typescript 1`] = `"[success] Generated modifier-test \`foo\` at \`tests/integration/modifiers/foo-test.gts\`."`;
+
+exports[`package-type: v2-app > generator: route > args: --log --test --typescript 1`] = `
+"[log] import Route from '@ember/routing/route';
+
+export default class FooRoute extends Route {}
+
+[log] import { module, test } from 'qunit';
+import { setupTest } from 'ember-qunit';
+
+module('Unit | Route | Foo', function (hooks) {
+  setupTest(hooks);
+
+  test('it exists', function (assert) {
+    const route = this.owner.lookup('route:foo');
+
+    assert.ok(route);
+  });
+});
+"
+`;
+
+exports[`package-type: v2-app > generator: route > args: --log --test 1`] = `
+"[log] import Route from '@ember/routing/route';
+
+export default class FooRoute extends Route {}
+
+[log] import { module, test } from 'qunit';
+import { setupTest } from 'ember-qunit';
+
+module('Unit | Route | Foo', function (hooks) {
+  setupTest(hooks);
+
+  test('it exists', function (assert) {
+    const route = this.owner.lookup('route:foo');
+
+    assert.ok(route);
+  });
+});
+"
+`;
+
+exports[`package-type: v2-app > generator: route > args: --log --typescript 1`] = `
+"[log] import Route from '@ember/routing/route';
+
+export default class FooRoute extends Route {}
+"
+`;
+
+exports[`package-type: v2-app > generator: route > args: --log 1`] = `
+"[log] import Route from '@ember/routing/route';
+
+export default class FooRoute extends Route {}
+"
+`;
+
+exports[`package-type: v2-app > generator: route > args: --test --typescript 1`] = `
+"[success] Generated route \`foo\` at \`app/routes/foo.ts\`.
+[success] Generated route-test \`foo\` at \`tests/unit/routes/foo-test.ts\`."
+`;
+
+exports[`package-type: v2-app > generator: route > args: --test 1`] = `
+"[success] Generated route \`foo\` at \`app/routes/foo.js\`.
+[success] Generated route-test \`foo\` at \`tests/unit/routes/foo-test.js\`."
+`;
+
+exports[`package-type: v2-app > generator: route > args: --typescript 1`] = `"[success] Generated route \`foo\` at \`app/routes/foo.ts\`."`;
+
+exports[`package-type: v2-app > generator: route-test > args: --log --typescript 1`] = `
+"[log] import { module, test } from 'qunit';
+import { setupTest } from 'ember-qunit';
+
+module('Unit | Route | Foo', function (hooks) {
+  setupTest(hooks);
+
+  test('it exists', function (assert) {
+    const route = this.owner.lookup('route:foo');
+
+    assert.ok(route);
+  });
+});
+"
+`;
+
+exports[`package-type: v2-app > generator: route-test > args: --log 1`] = `
+"[log] import { module, test } from 'qunit';
+import { setupTest } from 'ember-qunit';
+
+module('Unit | Route | Foo', function (hooks) {
+  setupTest(hooks);
+
+  test('it exists', function (assert) {
+    const route = this.owner.lookup('route:foo');
+
+    assert.ok(route);
+  });
+});
+"
+`;
+
+exports[`package-type: v2-app > generator: route-test > args: --typescript 1`] = `"[success] Generated route-test \`foo\` at \`tests/unit/routes/foo-test.ts\`."`;
+
+exports[`package-type: v2-app > generator: service > args: --log --test --typescript 1`] = `
+"[log] import Service from '@ember/service';
+
+export default class FooService extends Service {}
+
+declare module '@ember/service' {
+  interface Registry {
+    foo: FooService;
+  }
+}
+
+[log] import { module, test } from 'qunit';
+import { setupTest } from 'ember-qunit';
+
+module('Unit | Service | Foo', function (hooks) {
+  setupTest(hooks);
+
+  test('it exists', function (assert) {
+    const service = this.owner.lookup('service:foo');
+
+    assert.ok(service);
+  });
+});
+"
+`;
+
+exports[`package-type: v2-app > generator: service > args: --log --test 1`] = `
+"[log] import Service from '@ember/service';
+
+export default class FooService extends Service {}
+
+[log] import { module, test } from 'qunit';
+import { setupTest } from 'ember-qunit';
+
+module('Unit | Service | Foo', function (hooks) {
+  setupTest(hooks);
+
+  test('it exists', function (assert) {
+    const service = this.owner.lookup('service:foo');
+
+    assert.ok(service);
+  });
+});
+"
+`;
+
+exports[`package-type: v2-app > generator: service > args: --log --typescript 1`] = `
+"[log] import Service from '@ember/service';
+
+export default class FooService extends Service {}
+
+declare module '@ember/service' {
+  interface Registry {
+    foo: FooService;
+  }
+}
+"
+`;
+
+exports[`package-type: v2-app > generator: service > args: --log 1`] = `
+"[log] import Service from '@ember/service';
+
+export default class FooService extends Service {}
+"
+`;
+
+exports[`package-type: v2-app > generator: service > args: --test --typescript 1`] = `
+"[success] Generated service \`foo\` at \`app/services/foo.ts\`.
+[success] Generated service-test \`foo\` at \`tests/unit/services/foo-test.ts\`."
+`;
+
+exports[`package-type: v2-app > generator: service > args: --test 1`] = `
+"[success] Generated service \`foo\` at \`app/services/foo.js\`.
+[success] Generated service-test \`foo\` at \`tests/unit/services/foo-test.js\`."
+`;
+
+exports[`package-type: v2-app > generator: service > args: --typescript 1`] = `"[success] Generated service \`foo\` at \`app/services/foo.ts\`."`;
+
+exports[`package-type: v2-app > generator: service-test > args: --log --typescript 1`] = `
+"[log] import { module, test } from 'qunit';
+import { setupTest } from 'ember-qunit';
+
+module('Unit | Service | Foo', function (hooks) {
+  setupTest(hooks);
+
+  test('it exists', function (assert) {
+    const service = this.owner.lookup('service:foo');
+
+    assert.ok(service);
+  });
+});
+"
+`;
+
+exports[`package-type: v2-app > generator: service-test > args: --log 1`] = `
+"[log] import { module, test } from 'qunit';
+import { setupTest } from 'ember-qunit';
+
+module('Unit | Service | Foo', function (hooks) {
+  setupTest(hooks);
+
+  test('it exists', function (assert) {
+    const service = this.owner.lookup('service:foo');
+
+    assert.ok(service);
+  });
+});
+"
+`;
+
+exports[`package-type: v2-app > generator: service-test > args: --typescript 1`] = `"[success] Generated service-test \`foo\` at \`tests/unit/services/foo-test.ts\`."`;
+
+exports[`package-type: v2-app > generator: util > args: --log --namedExport --test --typescript 1`] = `
+"[log] export function foo() {
+  return true;
+}
+
+[log] import foo from 'v2-app/utils/foo';
+import { module, test } from 'qunit';
+
+module('Unit | Util | foo', function () {
+  test('it works', function (assert) {
+    const result = foo();
+
+    assert.ok(result);
+  });
+});
+"
+`;
+
+exports[`package-type: v2-app > generator: util > args: --log --namedExport --test 1`] = `
+"[log] export function foo() {
+  return true;
+}
+
+[log] import foo from 'v2-app/utils/foo';
+import { module, test } from 'qunit';
+
+module('Unit | Util | foo', function () {
+  test('it works', function (assert) {
+    const result = foo();
+
+    assert.ok(result);
+  });
+});
+"
+`;
+
+exports[`package-type: v2-app > generator: util > args: --log --namedExport --typescript 1`] = `
+"[log] export function foo() {
+  return true;
+}
+"
+`;
+
+exports[`package-type: v2-app > generator: util > args: --log --namedExport 1`] = `
+"[log] export function foo() {
+  return true;
+}
+"
+`;
+
+exports[`package-type: v2-app > generator: util > args: --log --test --typescript 1`] = `
+"[log] export default function foo() {
+  return true;
+}
+
+[log] import foo from 'v2-app/utils/foo';
+import { module, test } from 'qunit';
+
+module('Unit | Util | foo', function () {
+  test('it works', function (assert) {
+    const result = foo();
+
+    assert.ok(result);
+  });
+});
+"
+`;
+
+exports[`package-type: v2-app > generator: util > args: --log --test 1`] = `
+"[log] export default function foo() {
+  return true;
+}
+
+[log] import foo from 'v2-app/utils/foo';
+import { module, test } from 'qunit';
+
+module('Unit | Util | foo', function () {
+  test('it works', function (assert) {
+    const result = foo();
+
+    assert.ok(result);
+  });
+});
+"
+`;
+
+exports[`package-type: v2-app > generator: util > args: --log --typescript 1`] = `
+"[log] export default function foo() {
+  return true;
+}
+"
+`;
+
+exports[`package-type: v2-app > generator: util > args: --log 1`] = `
+"[log] export default function foo() {
+  return true;
+}
+"
+`;
+
+exports[`package-type: v2-app > generator: util > args: --namedExport --test --typescript 1`] = `
+"[success] Generated util \`foo\` at \`app/utils/foo.ts\`.
+[success] Generated util-test \`foo\` at \`tests/unit/utils/foo-test.ts\`."
+`;
+
+exports[`package-type: v2-app > generator: util > args: --namedExport --test 1`] = `
+"[success] Generated util \`foo\` at \`app/utils/foo.js\`.
+[success] Generated util-test \`foo\` at \`tests/unit/utils/foo-test.js\`."
+`;
+
+exports[`package-type: v2-app > generator: util > args: --namedExport --typescript 1`] = `"[success] Generated util \`foo\` at \`app/utils/foo.ts\`."`;
+
+exports[`package-type: v2-app > generator: util > args: --namedExport 1`] = `"[success] Generated util \`foo\` at \`app/utils/foo.js\`."`;
+
+exports[`package-type: v2-app > generator: util > args: --test --typescript 1`] = `
+"[success] Generated util \`foo\` at \`app/utils/foo.ts\`.
+[success] Generated util-test \`foo\` at \`tests/unit/utils/foo-test.ts\`."
+`;
+
+exports[`package-type: v2-app > generator: util > args: --test 1`] = `
+"[success] Generated util \`foo\` at \`app/utils/foo.js\`.
+[success] Generated util-test \`foo\` at \`tests/unit/utils/foo-test.js\`."
+`;
+
+exports[`package-type: v2-app > generator: util > args: --typescript 1`] = `"[success] Generated util \`foo\` at \`app/utils/foo.ts\`."`;
+
+exports[`package-type: v2-app > generator: util-test > args: --log --typescript 1`] = `
+"[log] import foo from 'v2-app/utils/foo';
+import { module, test } from 'qunit';
+
+module('Unit | Util | foo', function () {
+  test('it works', function (assert) {
+    const result = foo();
+
+    assert.ok(result);
+  });
+});
+"
+`;
+
+exports[`package-type: v2-app > generator: util-test > args: --log 1`] = `
+"[log] import foo from 'v2-app/utils/foo';
+import { module, test } from 'qunit';
+
+module('Unit | Util | foo', function () {
+  test('it works', function (assert) {
+    const result = foo();
+
+    assert.ok(result);
+  });
+});
+"
+`;
+
+exports[`package-type: v2-app > generator: util-test > args: --typescript 1`] = `"[success] Generated util-test \`foo\` at \`tests/unit/utils/foo-test.ts\`."`;
diff --git a/test/generators.test.ts b/test/generators.test.ts
new file mode 100644
index 0000000..6a89b5f
--- /dev/null
+++ b/test/generators.test.ts
@@ -0,0 +1,41 @@
+// @ts-expect-error: TODO: Types for `combinations` package:
+import combinations from "combinations";
+import { afterEach, describe, it } from "vitest";
+import { generators } from "../src/generators/generators.ts";
+import { Package } from "./helpers.ts";
+
+let pkg: Package;
+
+afterEach(() => pkg.cleanUp());
+
+const IGNORED_ARG_NAMES = ["copy", "destroy"];
+const IGNORED_ARG_TYPES = ["positional", "string"];
+
+for (const packageType of ["v1-addon", "v1-app", "v2-addon", "v2-app"]) {
+  describe(`package-type: ${packageType}`, () => {
+    for (const generator of generators) {
+      describe(`generator: ${generator.name}`, () => {
+        const argCombinations = combinations(
+          generator.args
+            .filter((arg) => {
+              return (
+                IGNORED_ARG_NAMES.includes(arg.name) === false &&
+                IGNORED_ARG_TYPES.includes(arg.type) === false
+              );
+            })
+            .map((arg) => `--${arg.name}`),
+        );
+
+        for (const args of argCombinations) {
+          it(`args: ${args.join(" ")}`, async (ctx) => {
+            pkg = await Package.create(packageType);
+
+            const { output } = await pkg.gember(generator.name, "foo", ...args);
+
+            ctx.expect(output).toMatchSnapshot();
+          });
+        }
+      });
+    }
+  });
+}
diff --git a/test/helpers.ts b/test/helpers.ts
index 039888a..a2bae4c 100644
--- a/test/helpers.ts
+++ b/test/helpers.ts
@@ -17,20 +17,22 @@ export class Package {
     await remove(this.path);
   }
 
-  static async create(name: string, path: string = uuidv4()): Promise<Package> {
+  static async create(type: string, path: string = uuidv4()): Promise<Package> {
     const pkg = new this(join("test", "output", path));
 
     await pkg.cleanUp();
-    await recursiveCopy(join("test", "packages", name), pkg.path);
+    await recursiveCopy(join("test", "packages", type), pkg.path);
 
     return pkg;
   }
 
-  async gember(...args: string[]): Promise<void> {
-    await execa(
+  async gember(...args: string[]): Promise<{ output: string }> {
+    const { stdout: output } = await execa(
       join(dirname(fileURLToPath(import.meta.url)), "..", "bin", "gember.js"),
       [...args, `--cwd=${this.path}`],
     );
+
+    return { output };
   }
 
   getPath(path: string): string {