Reset MockServer by clearing all expectations
546857
public MockServerClient reset() {
        MockServerEventBus.getInstance().publish(EventType.RESET);
        sendRequest(request().withMethod("PUT").withPath(calculatePath("reset")));
        return clientClass.cast(this);
    }
647520
def reset_mock(self,  visited=None, return_value=False, side_effect=False):
        ""
        if visited is None:
            visited = []
        if id(self) in visited:
            return
        visited.append(id(self))

        self.called = False
        self.call_args = None
        self.call_count = 0
        self.mock_calls = _CallList()
        self.call_args_list = _CallList()
        self.method_calls = _CallList()

        if return_value:
            self._mock_return_value = DEFAULT
        if side_effect:
            self._mock_side_effect = None

        for child in self._mock_children.values():
            if isinstance(child, _SpecState):
                continue
            child.reset_mock(visited)

        ret = self._mock_return_value
        if _is_instance_mock(ret) and ret is not self:
            ret.reset_mock(visited)
313450
void reset() {
        cd = initCd;
        serializer = initSerializer;
        in.position(initPosition);
        finalPosition = initFinalPosition;
        offset = initOffset;
    }
918790
function (config, mockSrc) {
    var dataWithContext = readMockManifest(config, mockSrc);

    // log('readScenarioData config', config);
    if (config.plugins) {
      dataWithContext = runPlugins(dataWithContext, config.plugins);
    }

    return removeContext(dataWithContext);
  }
40767
function reset () {
    var immutable = global.__immutable_core__
    // default options
    immutable.defaultAjv = new Ajv({
        allErrors: true,
        coerceTypes: 'array',
        removeAdditional: true,
        useDefaults: true,
        v5: true,
    })
    immutable.defaultAllowOverride = false
    immutable.defaultAutomock = undefined
    immutable.defaultCacheClient = undefined
    immutable.defaultFreeze = false
    immutable.defaultFreezeData = true
    immutable.defaultImmutableAI = true
    immutable.defaultLogClient = undefined
    immutable.defaultResolve = false
    immutable.defaultStrictArgs = true
    immutable.defaultValidateArgs = true
    immutable.defaultValidateReturn = true
    // global data stores
    immutable.binds = {}
    immutable.caches = {}
    immutable.functions = {}
    immutable.modules = {}
    // return immutable
    return ImmutableCore
}
521778
public final void reset() {
        successfulTests = 0;
        failedTests = 0;
        timeoutTests = 0;
        errorTests = 0;
        individualErrors = 0;

        startTime = null;
        endTime = null;
    }
148098
def reset_server_and_request_check(self, address):
        """"""
        with self._lock:
            self._reset_server(address)
            self._request_check(address)
1140470
function mock(_module, _exports) {
	delete require.cache[require.resolve(_module)];
	require(_module);
	_exports && (require.cache[require.resolve(_module)].exports = _exports);
	return require(_module);
}
961260
def reset_server(self):
        
        sushy_system = self._get_sushy_system(PROLIANT_SYSTEM_ID)
        try:
            sushy_system.reset_system(sushy.RESET_FORCE_RESTART)
        except sushy.exceptions.SushyError as e:
            msg = (self._('The Redfish controller failed to reset server. '
                          'Error %(error)s') %
                   {'error': str(e)})
            LOG.debug(msg)
            raise exception.IloError(msg)
472021
function delayMock(mock, delay) {
            mockService.update({'identifier': mock.identifier, 'delay': delay}, function () {
                vm.delays[mock.identifier] = delay;
            });
        }
658448
def reset(self):
        '''
        
        '''
        self.initializeSim()
        self.aLvlNow = self.kInit*np.ones(self.AgentCount) # Start simulation near SS
        self.aNrmNow = self.aLvlNow/self.pLvlNow
951571
def reset
      self.apikey = DEFAULT_APIKEY
      self.endpoint = DEFAULT_ENDPOINT
      self.sandbox_endpoint = DEFAULT_SANDBOX_ENDPOINT
      self.sandbox_enabled = DEFAULT_SANDBOX_ENABLED
      self.fmt = DEFAULT_FMT
    end
861223
protected function reset()
    {
        $this->protocolVersion = null;
        $this->headers = null;
        $this->requestTarget = null;
        $this->method = null;
        $this->uri = null;
    }
340525
public void restoreAllMockSubnet(final Collection<MockSubnet> subnets) {
        allMockSubnets.clear();
        if (null != subnets) {
            for (MockSubnet instance : subnets) {
                allMockSubnets.put(instance.getSubnetId(), instance);
            }
        }
    }
330572
function resetModule() {
            function resetTernServer() {
                if (_ternNodeDomain.ready()) {
                    _ternNodeDomain.exec('resetTernServer');
                }
            }
            
            if (_ternNodeDomain) {
                if (addFilesPromise) {
                    // If we're in the middle of added files, don't reset 
                    // until we're done
                    addFilesPromise.done(resetTernServer).fail(resetTernServer);
                } else {
                    resetTernServer();
                }
            }
        }
858283
async function reset () {
    // catch async errors
    try {
        if (immutableApp && immutableApp.server && immutableApp.started) {
            await stop()
        }
        // create global app instance with defaults set
        immutableApp = global.__immutable_app__ = _.cloneDeep(defaultGlobalConfig)
        // create new express app
        immutableApp.express = express()
    }
    catch (err) {
        throw err
    }
}
438300
function mockModule(moduleName) {
    scope();
    if(typeof moduleName === 'function'){
      return onMockCreate(new ModuleMock(getAsyncMock(moduleName, parentModule)));
    } else {
      const name = convertName(moduleName, parentModule);
      resetMock(name);
      return onMockCreate(new ModuleMock(getMock(name)));
    }
}