beforeEach(() => {
    container = new Container();
    sut = container.get(ExitProcedure);

    SESSION.getEnv = () => 'production';
    spyOn(OS, 'kill');
  });

 beforeEach(() => {
   container = new Container();
   this.selectedProject = {};
   this.dialogController = { ok: jasmine.createSpy('dialog controller ok()') };
   container.registerInstance(SelectedProject, this.selectedProject);
   container.registerInstance(DialogController, this.dialogController);
   sut = container.get(RenameModal);
 });

  beforeEach(() => {
    let container = new Container();
    container.registerInstance(ValidationController, { validate: () => [] });
    container.registerInstance(GithubAPI, { getContents: async () => { return { status: 404 }; } });

    sut = container.get(UrlInput);
    sut.state = {
      github: {}
    };
  });

    beforeEach(() => {
        let container = new Container();

        router = container.get(Router);
        routerConfig = container.get(RouterConfiguration);

        spyOn(routerConfig, 'map');

        app = new App();
    });

 beforeEach(() => {
   container = new Container();
   notification = {};
   container.registerInstance(Notification, notification);
   ipcRenderer = { send: jasmine.createSpy('send'), on: (evt, callback) => _messageCallback = callback };
   ELECTRON.getIpcRenderer = () => ipcRenderer;
   sut = new IPC({
     container: container
   });
 });

 beforeEach(() => {
   container = new Container();
   logger = {
     error: jasmine.createSpy('logger.error'),
     info: jasmine.createSpy('logger.info'),
     warn: jasmine.createSpy('logger.warn'),
     success: jasmine.createSpy('logger.success')
   };
   LogManager.getLogger = () => logger;
   sut = container.get(Notification);
 });

 it('creates real', () => {
   const container = new Container();
   routeLoader = container.get(TemplatingRouteLoader);
   const router = new Router(container, new History() as any);
   const childContainer = routeLoader.createChildContainer(router);
   const childRouter = childContainer.getChildRouter!();
   childRouter.parent = null;
   const resolver = childContainer.getResolver(Router);
   expect(resolver.strategy).toBe(3);
   expect(childContainer.hasResolver(Router));
   expect(childContainer.get(Router)).toBe(childRouter);
 });

 driverCreators.forEach((driverCreatorClass, propertyName) => {
   let driverCreatorInstance: DriverCreator = diContainer.get(driverCreatorClass)
   const { driverCreator, dispose } = driverCreatorInstance.makeDriver(context, propertyName, changes$)
   drivers[`${propertyName}$`] = driverCreator
   
   disposeMethods.add(dispose)
 })

 beforeEach(() => {
   container = new Container();
   settings = container.get(Settings);
   ELECTRON.getPath = (p: string) => {
     if (p === 'userData') return 'c:/appdata/monterey';
   };
   FS.join = (...args) => Array.prototype.slice.call(args).join('/');
   FS.access = (p: any, x: any) => Promise.resolve(true);
   FS.getConstants = () => {
     return {
       W_OK: true,
       R_OK: true
     };
   };
   sut = container.get(FileSystemLogger);
 });

    it('handles attribute changed when attached to custom element', async () => {
      const hrefValue = 'AASSSBBBVCVVCC';
      const controller = {
        viewModel: {} as any
      };
      container.registerInstance(Router, {
        ensureConfigured: () => {
          return Promise.resolve();
        },
        generate: () => hrefValue
      });
      container.registerInstance(Element, element = document.createElement('div'));
      routeHref = container.get(RouteHref);
      routeHref.isActive = true;
      (element as any).au = { 'route-href': routeHref, controller };

      const spy = spyOn(RouteHref.prototype, 'processChange').and.callThrough();
      expect(routeHref.attribute).toBe('href');
      routeHref.attributeChanged('href', 'href');
      expect(spy).toHaveBeenCalledTimes(1);
      await wait(100);
      expect(routeHref.isActive).toBe(true);
      expect(controller.viewModel.href).toBe(hrefValue);

      routeHref.attribute = 'link';
      routeHref.attributeChanged('link', 'href');
      expect(element.getAttribute('href')).toBe(null);
      expect(spy).toHaveBeenCalledTimes(2);
      await wait(100);
      expect(controller.viewModel.link).toBe(hrefValue);
    });