cli.test.js.snap

// Jest Snapshot v1, https://goo.gl/fbAQLP

exports[`java output 1`] = `
Object {
  "src/main/java/mypackage/$Module.java": "package mypackage;

import java.io.BufferedReader;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.IOException;
import java.io.Reader;
import java.io.UncheckedIOException;

import java.nio.charset.StandardCharsets;

import java.util.HashMap;
import java.util.Map;

import software.amazon.jsii.JsiiModule;

public final class $Module extends JsiiModule {
    private static final Map<String, String> MODULE_TYPES = load();

    private static Map<String, String> load() {
        final Map<String, String> result = new HashMap<>();
        final ClassLoader cl = $Module.class.getClassLoader();
        try (final InputStream is = cl.getResourceAsStream(\\"mypackage/$Module.txt\\");
             final Reader rd = new InputStreamReader(is, StandardCharsets.UTF_8);
             final BufferedReader br = new BufferedReader(rd)) {
            br.lines()
              .filter(line -> !line.trim().isEmpty())
              .forEach(line ->  {
                final String[] parts = line.split(\\"=\\", 2);
                final String fqn = parts[0];
                final String className = parts[1];
                result.put(fqn, className);
            });
        }
        catch (final IOException exception) {
            throw new UncheckedIOException(exception);
        }
        return result;
    }

    private final Map<String, Class<?>> cache = new HashMap<>();

    public $Module() {
        super(\\"generated\\", \\"0.0.0\\", $Module.class, \\"generated@0.0.0.jsii.tgz\\");
    }

    @Override
    protected Class<?> resolveClass(final String fqn) throws ClassNotFoundException {
        if (!MODULE_TYPES.containsKey(fqn)) {
            throw new ClassNotFoundException(\\"Unknown JSII type: \\" + fqn);
        }
        String className = MODULE_TYPES.get(fqn);
        if (!this.cache.containsKey(className)) {
            this.cache.put(className, this.findClass(className));
        }
        return this.cache.get(className);
    }

    private Class<?> findClass(final String binaryName) {
        try {
            return Class.forName(binaryName);
        }
        catch (final ClassNotFoundException exception) {
            throw new RuntimeException(exception);
        }
    }
}
",
  "src/main/java/mypackage/Calculator.java": "package mypackage;

/**
 * A sophisticaed multi-language calculator.
 */

@software.amazon.jsii.Jsii(module = mypackage.$Module.class, fqn = \\"generated.Calculator\\")
public class Calculator extends software.amazon.jsii.JsiiObject {

    protected Calculator(final software.amazon.jsii.JsiiObjectRef objRef) {
        super(objRef);
    }

    protected Calculator(final software.amazon.jsii.JsiiObject.InitializationMode initializationMode) {
        super(initializationMode);
    }

    public Calculator() {
        super(software.amazon.jsii.JsiiObject.InitializationMode.JSII);
        software.amazon.jsii.JsiiEngine.getInstance().createNewObject(this);
    }

    /**
     * Adds the two operands.
     * <p>
     * @param ops operands. This parameter is required.
     */
    public @org.jetbrains.annotations.NotNull java.lang.Number add(final @org.jetbrains.annotations.NotNull mypackage.Operands ops) {
        return this.jsiiCall(\\"add\\", java.lang.Number.class, new Object[] { java.util.Objects.requireNonNull(ops, \\"ops is required\\") });
    }

    /**
     * Multiplies the two operands.
     * <p>
     * @param ops operands. This parameter is required.
     */
    public @org.jetbrains.annotations.NotNull java.lang.Number mul(final @org.jetbrains.annotations.NotNull mypackage.Operands ops) {
        return this.jsiiCall(\\"mul\\", java.lang.Number.class, new Object[] { java.util.Objects.requireNonNull(ops, \\"ops is required\\") });
    }

    /**
     * Subtracts the two operands.
     * <p>
     * @param ops operands. This parameter is required.
     */
    public @org.jetbrains.annotations.NotNull java.lang.Number sub(final @org.jetbrains.annotations.NotNull mypackage.Operands ops) {
        return this.jsiiCall(\\"sub\\", java.lang.Number.class, new Object[] { java.util.Objects.requireNonNull(ops, \\"ops is required\\") });
    }
}
",
  "src/main/java/mypackage/Operands.java": "package mypackage;

/**
 * Math operands.
 */

@software.amazon.jsii.Jsii(module = mypackage.$Module.class, fqn = \\"generated.Operands\\")
@software.amazon.jsii.Jsii.Proxy(Operands.Jsii$Proxy.class)
public interface Operands extends software.amazon.jsii.JsiiSerializable {

    /**
     * Left-hand side operand.
     */
    @org.jetbrains.annotations.NotNull java.lang.Number getLhs();

    /**
     * Right-hand side operand.
     */
    @org.jetbrains.annotations.NotNull java.lang.Number getRhs();

    /**
     * @return a {@link Builder} of {@link Operands}
     */
    static Builder builder() {
        return new Builder();
    }
    /**
     * A builder for {@link Operands}
     */
    public static final class Builder implements software.amazon.jsii.Builder<Operands> {
        private java.lang.Number lhs;
        private java.lang.Number rhs;

        /**
         * Sets the value of {@link Operands#getLhs}
         * @param lhs Left-hand side operand. This parameter is required.
         * @return {@code this}
         */
        public Builder lhs(java.lang.Number lhs) {
            this.lhs = lhs;
            return this;
        }

        /**
         * Sets the value of {@link Operands#getRhs}
         * @param rhs Right-hand side operand. This parameter is required.
         * @return {@code this}
         */
        public Builder rhs(java.lang.Number rhs) {
            this.rhs = rhs;
            return this;
        }

        /**
         * Builds the configured instance.
         * @return a new instance of {@link Operands}
         * @throws NullPointerException if any required attribute was not provided
         */
        @Override
        public Operands build() {
            return new Jsii$Proxy(lhs, rhs);
        }
    }

    /**
     * An implementation for {@link Operands}
     */
    final class Jsii$Proxy extends software.amazon.jsii.JsiiObject implements Operands {
        private final java.lang.Number lhs;
        private final java.lang.Number rhs;

        /**
         * Constructor that initializes the object based on values retrieved from the JsiiObject.
         * @param objRef Reference to the JSII managed object.
         */
        protected Jsii$Proxy(final software.amazon.jsii.JsiiObjectRef objRef) {
            super(objRef);
            this.lhs = this.jsiiGet(\\"lhs\\", java.lang.Number.class);
            this.rhs = this.jsiiGet(\\"rhs\\", java.lang.Number.class);
        }

        /**
         * Constructor that initializes the object based on literal property values passed by the {@link Builder}.
         */
        private Jsii$Proxy(final java.lang.Number lhs, final java.lang.Number rhs) {
            super(software.amazon.jsii.JsiiObject.InitializationMode.JSII);
            this.lhs = java.util.Objects.requireNonNull(lhs, \\"lhs is required\\");
            this.rhs = java.util.Objects.requireNonNull(rhs, \\"rhs is required\\");
        }

        @Override
        public java.lang.Number getLhs() {
            return this.lhs;
        }

        @Override
        public java.lang.Number getRhs() {
            return this.rhs;
        }

        @Override
        public com.fasterxml.jackson.databind.JsonNode $jsii$toJson() {
            final com.fasterxml.jackson.databind.ObjectMapper om = software.amazon.jsii.JsiiObjectMapper.INSTANCE;
            final com.fasterxml.jackson.databind.node.ObjectNode data = com.fasterxml.jackson.databind.node.JsonNodeFactory.instance.objectNode();

            data.set(\\"lhs\\", om.valueToTree(this.getLhs()));
            data.set(\\"rhs\\", om.valueToTree(this.getRhs()));

            final com.fasterxml.jackson.databind.node.ObjectNode struct = com.fasterxml.jackson.databind.node.JsonNodeFactory.instance.objectNode();
            struct.set(\\"fqn\\", om.valueToTree(\\"generated.Operands\\"));
            struct.set(\\"data\\", data);

            final com.fasterxml.jackson.databind.node.ObjectNode obj = com.fasterxml.jackson.databind.node.JsonNodeFactory.instance.objectNode();
            obj.set(\\"$jsii.struct\\", struct);

            return obj;
        }

        @Override
        public boolean equals(Object o) {
            if (this == o) return true;
            if (o == null || getClass() != o.getClass()) return false;

            Operands.Jsii$Proxy that = (Operands.Jsii$Proxy) o;

            if (!lhs.equals(that.lhs)) return false;
            return this.rhs.equals(that.rhs);
        }

        @Override
        public int hashCode() {
            int result = this.lhs.hashCode();
            result = 31 * result + (this.rhs.hashCode());
            return result;
        }
    }
}
",
  "src/main/resources/mypackage/$Module.txt": "generated.Calculator=mypackage.Calculator
generated.Operands=mypackage.Operands
",
}
`;

exports[`jsii output 1`] = `
Object {
  "author": Object {
    "name": "generated@generated.com",
    "roles": Array [
      "author",
    ],
  },
  "description": "generated",
  "fingerprint": "+fSgo9PQwFAKmX2JcaRILwTXE/p1H1bq+QKuOREAfuE=",
  "homepage": "http://generated",
  "jsiiVersion": "1.6.0 (build 248e75b)",
  "license": "Apache-2.0",
  "name": "generated",
  "repository": Object {
    "type": "git",
    "url": "http://generated",
  },
  "schema": "jsii/0.10.0",
  "targets": Object {
    "js": Object {
      "npm": "generated",
    },
  },
  "types": Object {
    "generated.Calculator": Object {
      "assembly": "generated",
      "docs": Object {
        "summary": "A sophisticaed multi-language calculator.",
      },
      "fqn": "generated.Calculator",
      "initializer": Object {},
      "kind": "class",
      "locationInModule": Object {
        "filename": "lib/main.ts",
        "line": 19,
      },
      "methods": Array [
        Object {
          "docs": Object {
            "summary": "Adds the two operands.",
          },
          "locationInModule": Object {
            "filename": "lib/main.ts",
            "line": 24,
          },
          "name": "add",
          "parameters": Array [
            Object {
              "docs": Object {
                "summary": "operands.",
              },
              "name": "ops",
              "type": Object {
                "fqn": "generated.Operands",
              },
            },
          ],
          "returns": Object {
            "type": Object {
              "primitive": "number",
            },
          },
        },
        Object {
          "docs": Object {
            "summary": "Multiplies the two operands.",
          },
          "locationInModule": Object {
            "filename": "lib/main.ts",
            "line": 40,
          },
          "name": "mul",
          "parameters": Array [
            Object {
              "docs": Object {
                "summary": "operands.",
              },
              "name": "ops",
              "type": Object {
                "fqn": "generated.Operands",
              },
            },
          ],
          "returns": Object {
            "type": Object {
              "primitive": "number",
            },
          },
        },
        Object {
          "docs": Object {
            "summary": "Subtracts the two operands.",
          },
          "locationInModule": Object {
            "filename": "lib/main.ts",
            "line": 32,
          },
          "name": "sub",
          "parameters": Array [
            Object {
              "docs": Object {
                "summary": "operands.",
              },
              "name": "ops",
              "type": Object {
                "fqn": "generated.Operands",
              },
            },
          ],
          "returns": Object {
            "type": Object {
              "primitive": "number",
            },
          },
        },
      ],
      "name": "Calculator",
    },
    "generated.Operands": Object {
      "assembly": "generated",
      "datatype": true,
      "docs": Object {
        "summary": "Math operands.",
      },
      "fqn": "generated.Operands",
      "kind": "interface",
      "locationInModule": Object {
        "filename": "lib/main.ts",
        "line": 4,
      },
      "name": "Operands",
      "properties": Array [
        Object {
          "abstract": true,
          "docs": Object {
            "summary": "Left-hand side operand.",
          },
          "immutable": true,
          "locationInModule": Object {
            "filename": "lib/main.ts",
            "line": 8,
          },
          "name": "lhs",
          "type": Object {
            "primitive": "number",
          },
        },
        Object {
          "abstract": true,
          "docs": Object {
            "summary": "Right-hand side operand.",
          },
          "immutable": true,
          "locationInModule": Object {
            "filename": "lib/main.ts",
            "line": 13,
          },
          "name": "rhs",
          "type": Object {
            "primitive": "number",
          },
        },
      ],
    },
  },
  "version": "0.0.0",
}
`;

exports[`python output 1`] = `
Object {
  "my/python/module/__init__.py": "import abc
import builtins
import datetime
import enum
import typing

import jsii
import jsii.compat
import publication

from ._jsii import *


class Calculator(metaclass=jsii.JSIIMeta, jsii_type=\\"generated.Calculator\\"):
    \\"\\"\\"A sophisticaed multi-language calculator.\\"\\"\\"
    def __init__(self) -> None:
        jsii.create(Calculator, self, [])

    @jsii.member(jsii_name=\\"add\\")
    def add(self, *, lhs: jsii.Number, rhs: jsii.Number) -> jsii.Number:
        \\"\\"\\"Adds the two operands.

        :param lhs: Left-hand side operand.
        :param rhs: Right-hand side operand.
        \\"\\"\\"
        ops = Operands(lhs=lhs, rhs=rhs)

        return jsii.invoke(self, \\"add\\", [ops])

    @jsii.member(jsii_name=\\"mul\\")
    def mul(self, *, lhs: jsii.Number, rhs: jsii.Number) -> jsii.Number:
        \\"\\"\\"Multiplies the two operands.

        :param lhs: Left-hand side operand.
        :param rhs: Right-hand side operand.
        \\"\\"\\"
        ops = Operands(lhs=lhs, rhs=rhs)

        return jsii.invoke(self, \\"mul\\", [ops])

    @jsii.member(jsii_name=\\"sub\\")
    def sub(self, *, lhs: jsii.Number, rhs: jsii.Number) -> jsii.Number:
        \\"\\"\\"Subtracts the two operands.

        :param lhs: Left-hand side operand.
        :param rhs: Right-hand side operand.
        \\"\\"\\"
        ops = Operands(lhs=lhs, rhs=rhs)

        return jsii.invoke(self, \\"sub\\", [ops])


@jsii.data_type(jsii_type=\\"generated.Operands\\", jsii_struct_bases=[], name_mapping={'lhs': 'lhs', 'rhs': 'rhs'})
class Operands():
    def __init__(self, *, lhs: jsii.Number, rhs: jsii.Number) -> None:
        \\"\\"\\"Math operands.

        :param lhs: Left-hand side operand.
        :param rhs: Right-hand side operand.
        \\"\\"\\"
        self._values = {
            'lhs': lhs,
            'rhs': rhs,
        }

    @builtins.property
    def lhs(self) -> jsii.Number:
        \\"\\"\\"Left-hand side operand.\\"\\"\\"
        return self._values.get('lhs')

    @builtins.property
    def rhs(self) -> jsii.Number:
        \\"\\"\\"Right-hand side operand.\\"\\"\\"
        return self._values.get('rhs')

    def __eq__(self, rhs) -> bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs) -> bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return 'Operands(%s)' % ', '.join(k + '=' + repr(v) for k, v in self._values.items())


__all__ = [
    \\"Calculator\\",
    \\"Operands\\",
]

publication.publish()
",
  "my/python/module/_jsii/__init__.py": "import abc
import builtins
import datetime
import enum
import typing

import jsii
import jsii.compat
import publication

__jsii_assembly__ = jsii.JSIIAssembly.load(\\"generated\\", \\"0.0.0\\", __name__[0:-6], \\"generated@0.0.0.jsii.tgz\\")

__all__ = [
    \\"__jsii_assembly__\\",
]

publication.publish()
",
  "my/python/module/py.typed": "
",
}
`;