Unlock 30% off on Manual Testing Annual Plans this Holiday Season.

Copied to Clipboard!

How to use watcher method in stryker-parent

Best JavaScript code snippet using stryker-parent

mtime_file_watcher_test.py

Source:mtime_file_watcher_test.py

1#!/usr/bin/env python2#3# Copyright 2007 Google Inc.4#5# Licensed under the Apache License, Version 2.0 (the "License");6# you may not use this file except in compliance with the License.7# You may obtain a copy of the License at8#9#     http://www.apache.org/licenses/LICENSE-2.010#11# Unless required by applicable law or agreed to in writing, software12# distributed under the License is distributed on an "AS IS" BASIS,13# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.14# See the License for the specific language governing permissions and15# limitations under the License.16#17"""Tests for google.appengine.tools.devappserver2.mtime_file_watcher."""18import os19import os.path20import re21import shutil22import tempfile23import time24import unittest25from google.appengine.tools.devappserver2 import mtime_file_watcher26def _sync():27  time.sleep(.1)  # just to stay over the FS timestamp resolution28class TestMtimeFileWatcher(unittest.TestCase):29  """Tests for mtime_file_watcher.MtimeFileWatcher."""30  def setUp(self):31    self._directory = tempfile.mkdtemp()  # The watched directory32    self._junk_directory = tempfile.mkdtemp()  # A scrap directory.33    self._watcher = mtime_file_watcher.MtimeFileWatcher(self._directory)34  def tearDown(self):35    self._watcher.quit()36    shutil.rmtree(self._directory)37    shutil.rmtree(self._junk_directory)38  def _create_file(self, relative_path):39    realpath = os.path.realpath(os.path.join(self._directory, relative_path))40    with open(realpath, 'w'):41      pass42    return realpath43  def _create_directory(self, relative_path):44    realpath = os.path.realpath(os.path.join(self._directory, relative_path))45    os.mkdir(realpath)46    return realpath47  def test_file_created(self):48    self._watcher.start()49    self._watcher._startup_thread.join()50    path = self._create_file('test')51    self.assertEqual(self._watcher.changes(), {path})52  def test_skip_file_re(self):53    self._watcher.set_skip_files_re(re.compile('^.*skipped_file'))54    self._watcher.start()55    self._watcher._startup_thread.join()56    self._create_file('skipped_file')57    self.assertEqual(self._watcher.changes(), set())58    path = self._create_directory('subdir/')59    self.assertEqual(self._watcher.changes(), {path})60    path = self._create_file('subdir/skipped_file')61    # skip_files_re should also match subdirectories of watched directory.62    self.assertEqual(self._watcher.changes(), set())63    # Avoid polluting other tests.64    self._watcher.set_skip_files_re(None)65  def test_file_modified(self):66    path = self._create_file('test')67    _sync()68    self._watcher.start()69    self._watcher._startup_thread.join()70    with open(path, 'w') as f:71      f.write('testing')72    self.assertEqual(self._watcher.changes(), {path})73  def test_file_read(self):74    path = self._create_file('test')75    with open(path, 'w') as f:76      f.write('testing')77    self._watcher.start()78    self._watcher._startup_thread.join()79    with open(path, 'r') as f:80      f.read()81    # Reads should not trigger updates.82    self.assertEqual(self._watcher.changes(), set())83  def test_file_deleted(self):84    path = self._create_file('test')85    self._watcher.start()86    self._watcher._startup_thread.join()87    os.remove(path)88    self.assertEqual(self._watcher.changes(), {path})89  def test_file_renamed(self):90    source = self._create_file('test')91    target = os.path.join(os.path.dirname(source), 'test2')92    self._watcher.start()93    self._watcher._startup_thread.join()94    os.rename(source, target)95    self.assertEqual(self._watcher.changes(), {source, target})96  def test_create_directory(self):97    self._watcher.start()98    self._watcher._startup_thread.join()99    path = self._create_directory('test')100    self.assertEqual(self._watcher.changes(), {path})101  def test_skip_file_re_directory(self):102    self._watcher.set_skip_files_re(re.compile('.*skipped_dir'))103    self._watcher.start()104    self._watcher._startup_thread.join()105    self._create_directory('skipped_dir/')106    self.assertEqual(self._watcher.changes(), set())107    # If a directory is skipped, the files and directories in that directory108    # would also be skipped109    self._create_directory('skipped_dir/subdir/')110    self.assertEqual(self._watcher.changes(), set())111    path = self._create_directory('subdir/')112    self.assertEqual(self._watcher.changes(), {path})113    # skip_files_re should also match subdirectories of watched directory.114    path = self._create_directory('subdir/skipped_dir/')115    self.assertEqual(self._watcher.changes(), set())116    # Avoid polluting other tests.117    self._watcher.set_skip_files_re(None)118  def test_file_created_in_directory(self):119    self._create_directory('test')120    _sync()121    self._watcher.start()122    self._watcher._startup_thread.join()123    path = self._create_file('test/file')124    # Keep behavior consistency with inofiy_file_watcher,125    # parent directory of path should not be considered as changed.126    self.assertEqual(self._watcher.changes(), {path})127  def test_move_directory(self):128    source = self._create_directory('test')129    target = os.path.join(os.path.dirname(source), 'test2')130    self._watcher.start()131    self._watcher._startup_thread.join()132    os.rename(source, target)133    self.assertEqual(self._watcher.changes(), {source, target})134  def test_move_directory_out_of_watched(self):135    source = self._create_directory('test')136    target = os.path.join(self._junk_directory, 'test')137    self._watcher.start()138    self._watcher._startup_thread.join()139    os.rename(source, target)140    self.assertEqual(self._watcher.changes(), {source})141    with open(os.path.join(target, 'file'), 'w'):142      pass143    # Changes to files in subdirectories that have been moved should be ignored.144    self.assertEqual(self._watcher.changes(), set())145  def test_move_directory_into_watched(self):146    source = os.path.join(self._junk_directory, 'source')147    target = os.path.join(self._directory, 'target')148    os.mkdir(source)149    _sync()150    self._watcher.start()151    self._watcher._startup_thread.join()152    os.rename(source, target)153    self.assertEqual(self._watcher.changes(), {target})154    file_path = os.path.join(target, 'file')155    with open(file_path, 'w+'):156      pass157    # Keep behavior consistency with inofiy_file_watcher,158    # target should not be considered as changed.159    self.assertEqual(self._watcher.changes(), {file_path})160  def test_directory_deleted(self):161    path = self._create_directory('test')162    _sync()163    self._watcher.start()164    self._watcher._startup_thread.join()165    os.rmdir(path)166    self.assertEqual(self._watcher.changes(), {path})167  @unittest.skipUnless(hasattr(os, 'symlink'), 'requires os.symlink')168  def test_symlink(self):169    sym_target = os.path.join(self._directory, 'test')170    os.mkdir(os.path.join(self._junk_directory, 'subdir'))171    # the translated path in the target dir172    sym_subdir_path = os.path.join(sym_target, 'subdir')173    _sync()174    self._watcher.start()175    self._watcher._startup_thread.join()176    # Check that an added symlinked directory is reported.177    os.symlink(self._junk_directory, sym_target)178    self.assertEqual(179        self._watcher.changes(),180        {sym_target, os.path.join(sym_target, 'subdir')})181    # Check that a file added to the symlinked directory is reported.182    with open(os.path.join(self._junk_directory, 'file1'), 'w'):183      pass184    sym_file_path = os.path.join(sym_target, 'file1')185    # Keep behavior consistency with inofiy_file_watcher,186    # sym_target should not be considered as changed.187    self.assertEqual(188        self._watcher.changes(), {sym_file_path})189    # Check that a removed symlinked directory is reported.190    os.remove(sym_target)191    self.assertEqual(192        self._watcher.changes(), {sym_target, sym_file_path, sym_subdir_path})193    # Check that a file added to the removed symlinked directory is *not*194    # reported.195    with open(os.path.join(self._junk_directory, 'subdir', 'file2'), 'w'):196      pass197    self.assertEqual(self._watcher.changes(), set())198  def test_too_many_files(self):199    self._watcher.start()200    self._watcher._startup_thread.join()201    for i in range(10001):202      self._create_file('file%d' % i)203    self.assertEqual(len(self._watcher.changes()), 10000)204  @unittest.skipUnless(hasattr(os, 'symlink'), 'requires os.symlink')205  def test_symlink_loop(self):206    self._watcher.start()207    self._watcher._startup_thread.join()208    for i in range(1000):209      self._create_file('file%d' % i)210    for i in range(11):211      os.symlink(self._directory, os.path.join(self._directory, 'test%d' % i))212    # basically the set is completely crazy213    self.assertEqual(len(self._watcher.changes()), 10000)214if __name__ == '__main__':...

watchEventSource.js

Source:watchEventSource.js

1/*2	MIT License http://www.opensource.org/licenses/mit-license.php3	Author Tobias Koppers @sokra4*/5"use strict";6const fs = require("fs");7const path = require("path");8const { EventEmitter } = require("events");9const reducePlan = require("./reducePlan");10const IS_OSX = require("os").platform() === "darwin";11const IS_WIN = require("os").platform() === "win32";12const SUPPORTS_RECURSIVE_WATCHING = IS_OSX || IS_WIN;13const watcherLimit =14	+process.env.WATCHPACK_WATCHER_LIMIT || (IS_OSX ? 2000 : 10000);15const recursiveWatcherLogging = !!process.env16	.WATCHPACK_RECURSIVE_WATCHER_LOGGING;17let isBatch = false;18let watcherCount = 0;19/** @type {Map<Watcher, string>} */20const pendingWatchers = new Map();21/** @type {Map<string, RecursiveWatcher>} */22const recursiveWatchers = new Map();23/** @type {Map<string, DirectWatcher>} */24const directWatchers = new Map();25/** @type {Map<Watcher, RecursiveWatcher | DirectWatcher>} */26const underlyingWatcher = new Map();27class DirectWatcher {28	constructor(filePath) {29		this.filePath = filePath;30		this.watchers = new Set();31		this.watcher = undefined;32		try {33			const watcher = fs.watch(filePath);34			this.watcher = watcher;35			watcher.on("change", (type, filename) => {36				for (const w of this.watchers) {37					w.emit("change", type, filename);38				}39			});40			watcher.on("error", error => {41				for (const w of this.watchers) {42					w.emit("error", error);43				}44			});45		} catch (err) {46			process.nextTick(() => {47				for (const w of this.watchers) {48					w.emit("error", err);49				}50			});51		}52		watcherCount++;53	}54	add(watcher) {55		underlyingWatcher.set(watcher, this);56		this.watchers.add(watcher);57	}58	remove(watcher) {59		this.watchers.delete(watcher);60		if (this.watchers.size === 0) {61			directWatchers.delete(this.filePath);62			watcherCount--;63			if (this.watcher) this.watcher.close();64		}65	}66	getWatchers() {67		return this.watchers;68	}69}70class RecursiveWatcher {71	constructor(rootPath) {72		this.rootPath = rootPath;73		/** @type {Map<Watcher, string>} */74		this.mapWatcherToPath = new Map();75		/** @type {Map<string, Set<Watcher>>} */76		this.mapPathToWatchers = new Map();77		this.watcher = undefined;78		try {79			const watcher = fs.watch(rootPath, {80				recursive: true81			});82			this.watcher = watcher;83			watcher.on("change", (type, filename) => {84				if (!filename) {85					if (recursiveWatcherLogging) {86						process.stderr.write(87							`[watchpack] dispatch ${type} event in recursive watcher (${88								this.rootPath89							}) to all watchers\n`90						);91					}92					for (const w of this.mapWatcherToPath.keys()) {93						w.emit("change", type);94					}95				} else {96					const dir = path.dirname(filename);97					const watchers = this.mapPathToWatchers.get(dir);98					if (recursiveWatcherLogging) {99						process.stderr.write(100							`[watchpack] dispatch ${type} event in recursive watcher (${101								this.rootPath102							}) for '${filename}' to ${103								watchers ? watchers.size : 0104							} watchers\n`105						);106					}107					if (watchers === undefined) return;108					for (const w of watchers) {109						w.emit("change", type, path.basename(filename));110					}111				}112			});113			watcher.on("error", error => {114				for (const w of this.mapWatcherToPath.keys()) {115					w.emit("error", error);116				}117			});118		} catch (err) {119			process.nextTick(() => {120				for (const w of this.mapWatcherToPath.keys()) {121					w.emit("error", err);122				}123			});124		}125		watcherCount++;126		if (recursiveWatcherLogging) {127			process.stderr.write(128				`[watchpack] created recursive watcher at ${rootPath}\n`129			);130		}131	}132	add(filePath, watcher) {133		underlyingWatcher.set(watcher, this);134		const subpath = filePath.slice(this.rootPath.length + 1) || ".";135		this.mapWatcherToPath.set(watcher, subpath);136		const set = this.mapPathToWatchers.get(subpath);137		if (set === undefined) {138			const newSet = new Set();139			newSet.add(watcher);140			this.mapPathToWatchers.set(subpath, newSet);141		} else {142			set.add(watcher);143		}144	}145	remove(watcher) {146		const subpath = this.mapWatcherToPath.get(watcher);147		if (!subpath) return;148		this.mapWatcherToPath.delete(watcher);149		const set = this.mapPathToWatchers.get(subpath);150		set.delete(watcher);151		if (set.size === 0) {152			this.mapPathToWatchers.delete(subpath);153		}154		if (this.mapWatcherToPath.size === 0) {155			recursiveWatchers.delete(this.rootPath);156			watcherCount--;157			if (this.watcher) this.watcher.close();158			if (recursiveWatcherLogging) {159				process.stderr.write(160					`[watchpack] closed recursive watcher at ${this.rootPath}\n`161				);162			}163		}164	}165	getWatchers() {166		return this.mapWatcherToPath;167	}168}169class Watcher extends EventEmitter {170	close() {171		if (pendingWatchers.has(this)) {172			pendingWatchers.delete(this);173			return;174		}175		const watcher = underlyingWatcher.get(this);176		watcher.remove(this);177		underlyingWatcher.delete(this);178	}179}180const createDirectWatcher = filePath => {181	const existing = directWatchers.get(filePath);182	if (existing !== undefined) return existing;183	const w = new DirectWatcher(filePath);184	directWatchers.set(filePath, w);185	return w;186};187const createRecursiveWatcher = rootPath => {188	const existing = recursiveWatchers.get(rootPath);189	if (existing !== undefined) return existing;190	const w = new RecursiveWatcher(rootPath);191	recursiveWatchers.set(rootPath, w);192	return w;193};194const execute = () => {195	/** @type {Map<string, Watcher[] | Watcher>} */196	const map = new Map();197	const addWatcher = (watcher, filePath) => {198		const entry = map.get(filePath);199		if (entry === undefined) {200			map.set(filePath, watcher);201		} else if (Array.isArray(entry)) {202			entry.push(watcher);203		} else {204			map.set(filePath, [entry, watcher]);205		}206	};207	for (const [watcher, filePath] of pendingWatchers) {208		addWatcher(watcher, filePath);209	}210	pendingWatchers.clear();211	// Fast case when we are not reaching the limit212	if (!SUPPORTS_RECURSIVE_WATCHING || watcherLimit - watcherCount >= map.size) {213		// Create watchers for all entries in the map214		for (const [filePath, entry] of map) {215			const w = createDirectWatcher(filePath);216			if (Array.isArray(entry)) {217				for (const item of entry) w.add(item);218			} else {219				w.add(entry);220			}221		}222		return;223	}224	// Reconsider existing watchers to improving watch plan225	for (const watcher of recursiveWatchers.values()) {226		for (const [w, subpath] of watcher.getWatchers()) {227			addWatcher(w, path.join(watcher.rootPath, subpath));228		}229	}230	for (const watcher of directWatchers.values()) {231		for (const w of watcher.getWatchers()) {232			addWatcher(w, watcher.filePath);233		}234	}235	// Merge map entries to keep watcher limit236	// Create a 10% buffer to be able to enter fast case more often237	const plan = reducePlan(map, watcherLimit * 0.9);238	// Update watchers for all entries in the map239	for (const [filePath, entry] of plan) {240		if (entry.size === 1) {241			for (const [watcher, filePath] of entry) {242				const w = createDirectWatcher(filePath);243				const old = underlyingWatcher.get(watcher);244				if (old === w) continue;245				w.add(watcher);246				if (old !== undefined) old.remove(watcher);247			}248		} else {249			const filePaths = new Set(entry.values());250			if (filePaths.size > 1) {251				const w = createRecursiveWatcher(filePath);252				for (const [watcher, watcherPath] of entry) {253					const old = underlyingWatcher.get(watcher);254					if (old === w) continue;255					w.add(watcherPath, watcher);256					if (old !== undefined) old.remove(watcher);257				}258			} else {259				for (const filePath of filePaths) {260					const w = createDirectWatcher(filePath);261					for (const watcher of entry.keys()) {262						const old = underlyingWatcher.get(watcher);263						if (old === w) continue;264						w.add(watcher);265						if (old !== undefined) old.remove(watcher);266					}267				}268			}269		}270	}271};272exports.watch = filePath => {273	const watcher = new Watcher();274	// Find an existing watcher275	const directWatcher = directWatchers.get(filePath);276	if (directWatcher !== undefined) {277		directWatcher.add(watcher);278		return watcher;279	}280	let current = filePath;281	for (;;) {282		const recursiveWatcher = recursiveWatchers.get(current);283		if (recursiveWatcher !== undefined) {284			recursiveWatcher.add(filePath, watcher);285			return watcher;286		}287		const parent = path.dirname(current);288		if (parent === current) break;289		current = parent;290	}291	// Queue up watcher for creation292	pendingWatchers.set(watcher, filePath);293	if (!isBatch) execute();294	return watcher;295};296exports.batch = fn => {297	isBatch = true;298	try {299		fn();300	} finally {301		isBatch = false;302		execute();303	}304};305exports.getNumberOfWatchers = () => {306	return watcherCount;...

file_watcher.py

Source:file_watcher.py

...61    # Splits the allocated time between the watchers.62    timeout_ms /= len(self._file_watchers)63    return set.union(64        *[watcher.changes(timeout_ms) for watcher in self._file_watchers])65def _create_watcher(directories, watcher_class):66  """Creates the best watcher based on multiple directory support.67  For file watchers that can support multiple directories, directly instantiate68  an instance passing in an iterable of directories names. For file watchers69  that only support single directories, instantiate one directly if there is70  only a single directory to watch or wrap them in a MultipleFileWatcher if71  there are multiple directories to watch.72  Args:73    directories: An iterable of all the directories to watch.74    watcher_class: A callable that creates the per-directory FileWatcher75      instance. Must be callable with a single item of the type held by76      directories.77  Returns:78    A FileWatcher appropriate for the list of directories.79  """80  if watcher_class.SUPPORTS_MULTIPLE_DIRECTORIES:81    return watcher_class(directories)82  elif len(directories) == 1:83    return watcher_class(directories[0])84  else:85    return _MultipleFileWatcher([watcher_class(d) for d in directories])86def _create_linux_watcher(directories):87  """Create a watcher for Linux.88  While we prefer InotifyFileWatcher for Linux, there are only a limited number89  of inotify instances available per user (for example, 128 on a Goobuntu 12.0490  install). Try to create an InotifyFileWatcher but fall back on91  MTimeFileWatcher if the user is out of resources.92  Args:93    directories: A list representing the paths of the directories to monitor.94  Returns:95    An InotifyFileWatcher if the user has available resources and an96    MtimeFileWatcher if not.97  """98  # TODO: develop a way to check if the filesystem supports inotify.99  # (for example, NFS does not) and also use MTimeFileWatcher in that case.100  try:101    return _create_watcher(directories,102                           inotify_file_watcher.InotifyFileWatcher)103  except OSError as e:104    logging.warning('Could not create InotifyFileWatcher;'105                    ' falling back to MTimeFileWatcher: %s', e)106    return _create_watcher(directories, mtime_file_watcher.MtimeFileWatcher)107def get_file_watcher(directories, use_mtime_file_watcher):108  """Returns an instance that monitors a hierarchy of directories.109  Args:110    directories: A list representing the paths of the directories to monitor.111    use_mtime_file_watcher: A bool containing whether to use mtime polling to112        monitor file changes even if other options are available on the current113        platform.114  Returns:115    A FileWatcher appropriate for the current platform. start() must be called116    before changes().117  """118  assert not isinstance(directories, types.StringTypes), 'expected list got str'119  if use_mtime_file_watcher:120    return _create_watcher(directories, mtime_file_watcher.MtimeFileWatcher)121  elif sys.platform.startswith('linux'):122    return _create_linux_watcher(directories)123  elif sys.platform.startswith('win'):124    return _create_watcher(directories, win32_file_watcher.Win32FileWatcher)125  else:126    return _create_watcher(directories, mtime_file_watcher.MtimeFileWatcher)127  # NOTE: The Darwin-specific watcher implementation (found in the deleted file128  # fsevents_file_watcher.py) was incorrect - the Mac OS X FSEvents129  # implementation does not detect changes in symlinked files or directories. It130  # also does not provide file-level change precision before Mac OS 10.7.131  #132  # It is still possible to provide an efficient implementation by watching all133  # symlinked directories and using mtime checking for symlinked files. On any134  # change in a directory, it would have to be rescanned to see if a new135  # symlinked file or directory was added. It also might be possible to use...

watcher.spec.js

Source:watcher.spec.js

1import Vue from 'vue'2import Watcher from 'core/observer/watcher'3describe('Watcher', () => {4  let vm, spy5  beforeEach(() => {6    vm = new Vue({7      template: '<div></div>',8      data: {9        a: 1,10        b: {11          c: 2,12          d: 413        },14        c: 'c',15        msg: 'yo'16      }17    }).$mount()18    spy = jasmine.createSpy('watcher')19  })20  it('path', done => {21    const watcher = new Watcher(vm, 'b.c', spy)22    expect(watcher.value).toBe(2)23    vm.b.c = 324    waitForUpdate(() => {25      expect(watcher.value).toBe(3)26      expect(spy).toHaveBeenCalledWith(3, 2)27      vm.b = { c: 4 } // swapping the object28    }).then(() => {29      expect(watcher.value).toBe(4)30      expect(spy).toHaveBeenCalledWith(4, 3)31    }).then(done)32  })33  it('non-existent path, set later', done => {34    const watcher1 = new Watcher(vm, 'b.e', spy)35    expect(watcher1.value).toBeUndefined()36    // check $add should not affect isolated children37    const child2 = new Vue({ parent: vm })38    const watcher2 = new Watcher(child2, 'b.e', spy)39    expect(watcher2.value).toBeUndefined()40    Vue.set(vm.b, 'e', 123)41    waitForUpdate(() => {42      expect(watcher1.value).toBe(123)43      expect(watcher2.value).toBeUndefined()44      expect(spy.calls.count()).toBe(1)45      expect(spy).toHaveBeenCalledWith(123, undefined)46    }).then(done)47  })48  it('delete', done => {49    const watcher = new Watcher(vm, 'b.c', spy)50    expect(watcher.value).toBe(2)51    Vue.delete(vm.b, 'c')52    waitForUpdate(() => {53      expect(watcher.value).toBeUndefined()54      expect(spy).toHaveBeenCalledWith(undefined, 2)55    }).then(done)56  })57  it('path containing $data', done => {58    const watcher = new Watcher(vm, '$data.b.c', spy)59    expect(watcher.value).toBe(2)60    vm.b = { c: 3 }61    waitForUpdate(() => {62      expect(watcher.value).toBe(3)63      expect(spy).toHaveBeenCalledWith(3, 2)64      vm.$data.b.c = 465    }).then(() => {66      expect(watcher.value).toBe(4)67      expect(spy).toHaveBeenCalledWith(4, 3)68    }).then(done)69  })70  it('deep watch', done => {71    let oldB72    new Watcher(vm, 'b', spy, {73      deep: true74    })75    vm.b.c = { d: 4 }76    waitForUpdate(() => {77      expect(spy).toHaveBeenCalledWith(vm.b, vm.b)78      oldB = vm.b79      vm.b = { c: [{ a: 1 }] }80    }).then(() => {81      expect(spy).toHaveBeenCalledWith(vm.b, oldB)82      expect(spy.calls.count()).toBe(2)83      vm.b.c[0].a = 284    }).then(() => {85      expect(spy).toHaveBeenCalledWith(vm.b, vm.b)86      expect(spy.calls.count()).toBe(3)87    }).then(done)88  })89  it('deep watch $data', done => {90    new Watcher(vm, '$data', spy, {91      deep: true92    })93    vm.b.c = 394    waitForUpdate(() => {95      expect(spy).toHaveBeenCalledWith(vm.$data, vm.$data)96    }).then(done)97  })98  it('deep watch with circular references', done => {99    new Watcher(vm, 'b', spy, {100      deep: true101    })102    Vue.set(vm.b, '_', vm.b)103    waitForUpdate(() => {104      expect(spy).toHaveBeenCalledWith(vm.b, vm.b)105      expect(spy.calls.count()).toBe(1)106      vm.b._.c = 1107    }).then(() => {108      expect(spy).toHaveBeenCalledWith(vm.b, vm.b)109      expect(spy.calls.count()).toBe(2)110    }).then(done)111  })112  it('fire change for prop addition/deletion in non-deep mode', done => {113    new Watcher(vm, 'b', spy)114    Vue.set(vm.b, 'e', 123)115    waitForUpdate(() => {116      expect(spy).toHaveBeenCalledWith(vm.b, vm.b)117      expect(spy.calls.count()).toBe(1)118      Vue.delete(vm.b, 'e')119    }).then(() => {120      expect(spy.calls.count()).toBe(2)121    }).then(done)122  })123  it('watch function', done => {124    const watcher = new Watcher(vm, function () {125      return this.a + this.b.d126    }, spy)127    expect(watcher.value).toBe(5)128    vm.a = 2129    waitForUpdate(() => {130      expect(spy).toHaveBeenCalledWith(6, 5)131      vm.b = { d: 2 }132    }).then(() => {133      expect(spy).toHaveBeenCalledWith(4, 6)134    }).then(done)135  })136  it('lazy mode', done => {137    const watcher = new Watcher(vm, function () {138      return this.a + this.b.d139    }, null, { lazy: true })140    expect(watcher.lazy).toBe(true)141    expect(watcher.value).toBeUndefined()142    expect(watcher.dirty).toBe(true)143    watcher.evaluate()144    expect(watcher.value).toBe(5)145    expect(watcher.dirty).toBe(false)146    vm.a = 2147    waitForUpdate(() => {148      expect(watcher.value).toBe(5)149      expect(watcher.dirty).toBe(true)150      watcher.evaluate()151      expect(watcher.value).toBe(6)152      expect(watcher.dirty).toBe(false)153    }).then(done)154  })155  it('teardown', done => {156    const watcher = new Watcher(vm, 'b.c', spy)157    watcher.teardown()158    vm.b.c = 3159    waitForUpdate(() => {160      expect(watcher.active).toBe(false)161      expect(spy).not.toHaveBeenCalled()162    }).then(done)163  })164  it('warn not support path', () => {165    new Watcher(vm, 'd.e + c', spy)166    expect('Failed watching path:').toHaveBeenWarned()167  })...

browser_watcher.gypi

Source:browser_watcher.gypi

1# Copyright (c) 2014 The Chromium Authors. All rights reserved.2# Use of this source code is governed by a BSD-style license that can be3# found in the LICENSE file.4{5  'conditions': [6  ['OS=="win"', {7      'targets': [8          {9            # This is a separate lib to minimize the dependencies for its10            # hosting binary "chrome_watcher.dll".11            'target_name': 'browser_watcher',12            'type': 'static_library',13            'sources': [14              'browser_watcher/endsession_watcher_window_win.cc',15              'browser_watcher/endsession_watcher_window_win.h',16              'browser_watcher/exit_code_watcher_win.cc',17              'browser_watcher/exit_code_watcher_win.h',18              'browser_watcher/exit_funnel_win.cc',19              'browser_watcher/exit_funnel_win.h',20              'browser_watcher/window_hang_monitor_win.cc',21              'browser_watcher/window_hang_monitor_win.h',22            ],23            'dependencies': [24              '../base/base.gyp:base',25            ],26          },27          {28            # Users of the watcher link this target.29            'target_name': 'browser_watcher_client',30            'type': 'static_library',31            'sources': [32              'browser_watcher/crash_reporting_metrics_win.cc',33              'browser_watcher/crash_reporting_metrics_win.h',34              'browser_watcher/watcher_client_win.cc',35              'browser_watcher/watcher_client_win.h',36              'browser_watcher/watcher_metrics_provider_win.cc',37              'browser_watcher/watcher_metrics_provider_win.h',38            ],39            'dependencies': [40              '../base/base.gyp:base',41            ],42          },43        ],44      }45    ],46  ],...

getWatcherManager.js

Source:getWatcherManager.js

1/*2	MIT License http://www.opensource.org/licenses/mit-license.php3	Author Tobias Koppers @sokra4*/5"use strict";6const path = require("path");7const DirectoryWatcher = require("./DirectoryWatcher");8class WatcherManager {9	constructor(options) {10		this.options = options;11		this.directoryWatchers = new Map();12	}13	getDirectoryWatcher(directory) {14		const watcher = this.directoryWatchers.get(directory);15		if (watcher === undefined) {16			const newWatcher = new DirectoryWatcher(this, directory, this.options);17			this.directoryWatchers.set(directory, newWatcher);18			newWatcher.on("closed", () => {19				this.directoryWatchers.delete(directory);20			});21			return newWatcher;22		}23		return watcher;24	}25	watchFile(p, startTime) {26		const directory = path.dirname(p);27		if (directory === p) return null;28		return this.getDirectoryWatcher(directory).watch(p, startTime);29	}30	watchDirectory(directory, startTime) {31		return this.getDirectoryWatcher(directory).watch(directory, startTime);32	}33}34const watcherManagers = new WeakMap();35/**36 * @param {object} options options37 * @returns {WatcherManager} the watcher manager38 */39module.exports = options => {40	const watcherManager = watcherManagers.get(options);41	if (watcherManager !== undefined) return watcherManager;42	const newWatcherManager = new WatcherManager(options);43	watcherManagers.set(options, newWatcherManager);44	return newWatcherManager;45};...

Using AI Code Generation

1var parent = require('stryker-parent');2var watcher = parent.watcher();3watcher.on('change', function (file) {4    console.log('File changed: ' + file);5});6watcher.on('add', function (file) {7    console.log('File added: ' + file);8});9watcher.on('unlink', function (file) {10    console.log('File removed: ' + file);11});12watcher.on('error', function (error) {13    console.log('Error: ' + error);14});15var parent = require('stryker-parent');16parent.listFiles(function (error, files) {17    if (error) {18        console.log(error);19    } else {20        console.log(files);21    }22});23var parent = require('stryker-parent');24parent.listFiles(function (error, files) {25    if (error) {26        console.log(error);27    } else {28        console.log(files);29    }30});31var parent = require('stryker-parent');32parent.listFiles(function (error, files) {33    if (error) {34        console.log(error);35    } else {36        console.log(files);37    }38});39var parent = require('stryker-parent');40parent.listFiles(function (error, files) {41    if (error) {42        console.log(error);43    } else {44        console.log(files);45    }46});47var parent = require('stryker-parent');48parent.listFiles(function (error, files) {49    if (error) {50        console.log(error);51    } else {52        console.log(files);53    }54});55var parent = require('stryker-parent');56parent.listFiles(function (error, files) {57    if (error) {58        console.log(error);59    } else {60        console.log(files);61    }62});63var parent = require('stryker-parent');64parent.listFiles(function (error, files) {65    if (error) {66        console.log(error);67    } else {68        console.log(files);69    }70});

Using AI Code Generation

1var watcher = require('stryker-parent').watcher;2watcher.watch('test.js', function () {3    console.log('test.js has changed!');4});5var watcher = require('stryker-parent').watcher;6watcher.watch('test.html', function () {7    console.log('test.html has changed!');8});

Using AI Code Generation

1const { Watcher } = require('stryker-parent');2const watcher = new Watcher();3watcher.watch(['src/**/*.js'], ['test/**/*.js'], ['node', 'test.js']);4const { Watcher } = require('stryker');5const watcher = new Watcher();6watcher.watch(['src/**/*.js'], ['test/**/*.js'], ['node', 'test.js']);

Using AI Code Generation

1var strykerParent = require('stryker-parent');2var path = require('path');3var watcher = strykerParent.watcher;4var files = ['test.js', 'test2.js'];5var filesToMutate = ['test.js'];6var basePath = process.cwd();7var strykerOptions = { files, filesToMutate, basePath };8var stryker = new watcher.StrykerWatcher(strykerOptions);9stryker.start();10var strykerParent = require('stryker-parent');11var path = require('path');12var watcher = strykerParent.watcher;13var files = ['test.js', 'test2.js'];14var filesToMutate = ['test.js'];15var basePath = process.cwd();16var strykerOptions = { files, filesToMutate, basePath };17var stryker = new watcher.StrykerWatcher(strykerOptions);18stryker.start();19var strykerParent = require('stryker-parent');20var path = require('path');21var watcher = strykerParent.watcher;22var files = ['test.js', 'test2.js'];23var filesToMutate = ['test.js'];24var basePath = process.cwd();25var strykerOptions = { files, filesToMutate, basePath };26var stryker = new watcher.StrykerWatcher(strykerOptions);27stryker.start();28var strykerParent = require('stryker-parent');29var path = require('path');30var watcher = strykerParent.watcher;31var files = ['test.js', 'test2.js'];32var filesToMutate = ['test.js'];33var basePath = process.cwd();34var strykerOptions = { files, filesToMutate, basePath };

Using AI Code Generation

1var watcher = require('stryker-parent').watcher;2watcher.watch('test', function() {3});4var watcher = require('stryker-parent').watcher;5watcher.watch('test', function() {6});7var watcher = require('stryker-parent').watcher;8watcher.watch('test', function() {9});10var watcher = require('stryker-parent').watcher;11watcher.watch('test', function() {12});13var watcher = require('stryker-parent').watcher;14watcher.watch('test', function() {15});16var watcher = require('stryker-parent').watcher;17watcher.watch('test', function() {18});19var watcher = require('stryker-parent').watcher;20watcher.watch('test', function() {21});22var watcher = require('stryker-parent').watcher;23watcher.watch('test', function() {24});25var watcher = require('stryker-parent').watcher;26watcher.watch('test', function() {27});28var watcher = require('stryker-parent').watcher;29watcher.watch('test', function() {30});31var watcher = require('stryker-parent').watcher;32watcher.watch('test', function() {33});

Automation Testing Tutorials

Learn to execute automation testing from scratch with LambdaTest Learning Hub. Right from setting up the prerequisites to run your first automation test, to following best practices and diving deeper into advanced test scenarios. LambdaTest Learning Hubs compile a list of step-by-step guides to help you be proficient with different test automation frameworks i.e. Selenium, Cypress, TestNG etc.