Search some code: Max results:

Found 43200 results in 2003 files (71MB index data, 19275735 ngram matches, 6285 docs considered, 2954 docs (96MB) loaded, 772 docs skipped): for
(and substr:"class" substr:"needle") with options &zoekt.SearchOptions{EstimateDocCount:false, Whole:false, ShardMaxMatchCount:250, TotalMaxMatchCount:1000000, ShardMaxImportantMatch:2, TotalMaxImportantMatch:100, MaxWallTime:10000000000}
in 7.308132644s (queued: 2.361µs)

github.com/GoogleChrome/web-audio-samples:stress-test/boxes/third-party/prototype-1.6.0.2.js:[gh-pages, ]

41: var Class = {
2293:         'class': 'className',
56:       var subclass = function() { };
57:       subclass.prototype = parent.prototype;
1816:   classNames: function(element) {
2165:       className: 'class',
2625:   function findDOMClass(tagName) {
4187: Element.ClassNames.prototype = {
1820:   hasClassName: function(element, className) {
1827:   addClassName: function(element, className) {
1834:   removeClassName: function(element, className) {
1841:   toggleClassName: function(element, className) {
51:     Object.extend(klass, Class.Methods);
74: Class.Methods = {
286: var PeriodicalExecuter = Class.create({
552: var Template = Class.create({
988: var Hash = Class.create(Enumerable, (function() {
1083: var ObjectRange = Class.create(Enumerable, {
1157: Ajax.Base = Class.create({
1179: Ajax.Request = Class.create(Ajax.Base, {
1352: Ajax.Response = Class.create({
1426: Ajax.Updater = Class.create(Ajax.Request, {
1462: Ajax.PeriodicalUpdater = Class.create(Ajax.Base, {
1667:     $H({'id': 'id', 'className': 'class'}).each(function(pair) {
2696: /* Portions of the Selector class are derived from Jack Slocum’s DomQuery,
2700: var Selector = Class.create({
2846:     className:    "[contains(concat(' ', @class, ' '), ' #{1} ')]",
3146:       var needle = ' ' + className + ' ';
3150:         if (nodeClassName == className || (' ' + nodeClassName + ' ').include(needle))
3634: Abstract.TimedObserver = Class.create(PeriodicalExecuter, {
3651: Form.Element.Observer = Class.create(Abstract.TimedObserver, {
3657: Form.Observer = Class.create(Abstract.TimedObserver, {
3665: Abstract.EventObserver = Class.create({
3704: Form.Element.EventObserver = Class.create(Abstract.EventObserver, {
3710: Form.EventObserver = Class.create(Abstract.EventObserver, {
4153:     return name.blank() ? null : "[contains(concat(' ', @class, ' '), ' " + name + " ')]";
4186: Element.ClassNames = Class.create();
52:     klass.superclass = parent;
58:       klass.prototype = new subclass;
76:     var ancestor   = this.superclass && this.superclass.prototype;
1817:     return new Element.ClassNames(element);
1822:     var elementClassName = element.className;
1823:     return (elementClassName.length > 0 && (elementClassName == className ||
1824:       new RegExp("(^|\\s)" + className + "(\\s|$)").test(elementClassName)));
1829:     if (!element.hasClassName(className))
1830:       element.className += (element.className ? ' ' : '') + className;
1836:     element.className = element.className.replace(
1837:       new RegExp("(^|\\s+)" + className + "(\\s+|$)"), ' ').strip();
1843:     return element[element.hasClassName(className) ?
1844:       'removeClassName' : 'addClassName'](className);
2657:       var klass = findDOMClass(tag);
2940:     className:    'n = h.className(n, r, "#{1}", c);    c = false;',
2968:     className:    /^\.([\w\-\*]+)(\b|$)/,
2981:     className: function(element, matches) {
3139:     className: function(nodes, root, className, combinator) {
3141:       return Selector.handlers.byClassName(nodes, root, className);
3144:     byClassName: function(nodes, root, className) {
3148:         nodeClassName = node.className;
4157:   function(element, className) {
4158:     className = className.toString().strip();
4159:     var cond = /\s/.test(className) ? $w(className).map(iter).join('') : iter(className);
4161:   } : function(element, className) {
4162:     className = className.toString().strip();
4163:     var elements = [], classNames = (/\s/.test(className) ? $w(className) : null);
4164:     if (!classNames && !className) return elements;
4167:     className = ' ' + className + ' ';
4170:       if (child.className && (cn = ' ' + child.className + ' ') && (cn.include(className) ||
4171:           (classNames && classNames.all(function(name) {
4179:   return function(className, parentElement) {
4180:     return $(parentElement || document.body).getElementsByClassName(className);
4193:     this.element.className.split(/\s+/).select(function(name) {
4198:   set: function(className) {
4199:     this.element.className = className;
4202:   add: function(classNameToAdd) {
4203:     if (this.include(classNameToAdd)) return;
4204:     this.set($A(this).concat(classNameToAdd).join(' '));
4207:   remove: function(classNameToRemove) {
4208:     if (!this.include(classNameToRemove)) return;
4209:     this.set($A(this).without(classNameToRemove).join(' '));
4217: Object.extend(Element.ClassNames.prototype, Enumerable);
53:     klass.subclasses = [];
59:       parent.subclasses.push(klass);
2982:       return Element.hasClassName(element, matches[1]);
3147:       for (var i = 0, results = [], node, nodeClassName; node = nodes[i]; i++) {
3149:         if (nodeClassName.length == 0) continue;
4151: if (!document.getElementsByClassName) document.getElementsByClassName = function(instanceMethods){
4156:   instanceMethods.getElementsByClassName = Prototype.BrowserFeatures.XPath ?
eclipse.googlesource.com/jgit/jgit:org.eclipse.jgit/src/org/eclipse/jgit/util/RawSubStringPattern.java:[master, ]
59: 	private final byte[] needle;
57: 	private final String needleString;
56: public class RawSubStringPattern {
75: 		needle = new byte[b.length];
77: 			needle[i] = lc(b[i]);
91: 		final int needleLen = needle.length;
92: 		final byte first = needle[0];
109: 				if (neq(needle[j], text[si]))
72: 		needleString = patternText;
96: 		final int maxPos = rcs.endPtr - needleLen;
108: 			for (int j = 1; j < needleLen; j++, si++) {
131: 		return needleString;
github.com/google/caja:third_party/js/sunspider-benchmark/parse-only/prototype-1.6.0.3.js:[master, ]
44: var Class = {
2312:         'class': 'className',
59:       var subclass = function() { };
60:       subclass.prototype = parent.prototype;
1830:   classNames: function(element) {
2171:       className: 'class',
2644:   function findDOMClass(tagName) {
4286: Element.ClassNames.prototype = {
1834:   hasClassName: function(element, className) {
1841:   addClassName: function(element, className) {
1848:   removeClassName: function(element, className) {
1855:   toggleClassName: function(element, className) {
54:     Object.extend(klass, Class.Methods);
77: Class.Methods = {
294: var PeriodicalExecuter = Class.create({
560: var Template = Class.create({
997: var Hash = Class.create(Enumerable, (function() {
1094: var ObjectRange = Class.create(Enumerable, {
1168: Ajax.Base = Class.create({
1190: Ajax.Request = Class.create(Ajax.Base, {
1363: Ajax.Response = Class.create({
1437: Ajax.Updater = Class.create(Ajax.Request, {
1473: Ajax.PeriodicalUpdater = Class.create(Ajax.Base, {
1681:     $H({'id': 'id', 'className': 'class'}).each(function(pair) {
2721: /* Portions of the Selector class are derived from Jack Slocum's DomQuery,
2725: var Selector = Class.create({
2913:     className:    "[contains(concat(' ', @class, ' '), ' #{1} ')]",
3213:       var needle = ' ' + className + ' ';
3217:         if (nodeClassName == className || (' ' + nodeClassName + ' ').include(needle))
3704: Abstract.TimedObserver = Class.create(PeriodicalExecuter, {
3721: Form.Element.Observer = Class.create(Abstract.TimedObserver, {
3727: Form.Observer = Class.create(Abstract.TimedObserver, {
3735: Abstract.EventObserver = Class.create({
3774: Form.Element.EventObserver = Class.create(Abstract.EventObserver, {
3780: Form.EventObserver = Class.create(Abstract.EventObserver, {
4252:     return name.blank() ? null : "[contains(concat(' ', @class, ' '), ' " + name + " ')]";
4285: Element.ClassNames = Class.create();
55:     klass.superclass = parent;
61:       klass.prototype = new subclass;
79:     var ancestor   = this.superclass && this.superclass.prototype;
1831:     return new Element.ClassNames(element);
1836:     var elementClassName = element.className;
1837:     return (elementClassName.length > 0 && (elementClassName == className ||
1838:       new RegExp("(^|\\s)" + className + "(\\s|$)").test(elementClassName)));
1843:     if (!element.hasClassName(className))
1844:       element.className += (element.className ? ' ' : '') + className;
1850:     element.className = element.className.replace(
1851:       new RegExp("(^|\\s+)" + className + "(\\s+|$)"), ' ').strip();
1857:     return element[element.hasClassName(className) ?
1858:       'removeClassName' : 'addClassName'](className);
2676:       var klass = findDOMClass(tag);
3007:     className:    'n = h.className(n, r, "#{1}", c);    c = false;',
3035:     className:    /^\.([\w\-\*]+)(\b|$)/,
3048:     className: function(element, matches) {
3206:     className: function(nodes, root, className, combinator) {
3208:       return Selector.handlers.byClassName(nodes, root, className);
3211:     byClassName: function(nodes, root, className) {
3215:         nodeClassName = node.className;
4256:   function(element, className) {
4257:     className = className.toString().strip();
4258:     var cond = /\s/.test(className) ? $w(className).map(iter).join('') : iter(className);
4260:   } : function(element, className) {
4261:     className = className.toString().strip();
4262:     var elements = [], classNames = (/\s/.test(className) ? $w(className) : null);
4263:     if (!classNames && !className) return elements;
4266:     className = ' ' + className + ' ';
4269:       if (child.className && (cn = ' ' + child.className + ' ') && (cn.include(className) ||
4270:           (classNames && classNames.all(function(name) {
4278:   return function(className, parentElement) {
4279:     return $(parentElement || document.body).getElementsByClassName(className);
4292:     this.element.className.split(/\s+/).select(function(name) {
4297:   set: function(className) {
4298:     this.element.className = className;
4301:   add: function(classNameToAdd) {
4302:     if (this.include(classNameToAdd)) return;
4303:     this.set($A(this).concat(classNameToAdd).join(' '));
4306:   remove: function(classNameToRemove) {
4307:     if (!this.include(classNameToRemove)) return;
4308:     this.set($A(this).without(classNameToRemove).join(' '));
4316: Object.extend(Element.ClassNames.prototype, Enumerable);
56:     klass.subclasses = [];
62:       parent.subclasses.push(klass);
3049:       return Element.hasClassName(element, matches[1]);
3214:       for (var i = 0, results = [], node, nodeClassName; node = nodes[i]; i++) {
3216:         if (nodeClassName.length == 0) continue;
4250: if (!document.getElementsByClassName) document.getElementsByClassName = function(instanceMethods){
4255:   instanceMethods.getElementsByClassName = Prototype.BrowserFeatures.XPath ?
chromium.googlesource.com/external/w3c/csswg-test:work-in-progress/gabriele/css-xml-dom/js/prototype.js:[master, ]
44: var Class = {
2312:         'class': 'className',
59:       var subclass = function() { };
60:       subclass.prototype = parent.prototype;
1830:   classNames: function(element) {
2171:       className: 'class',
2644:   function findDOMClass(tagName) {
4286: Element.ClassNames.prototype = {
1834:   hasClassName: function(element, className) {
1841:   addClassName: function(element, className) {
1848:   removeClassName: function(element, className) {
1855:   toggleClassName: function(element, className) {
54:     Object.extend(klass, Class.Methods);
77: Class.Methods = {
294: var PeriodicalExecuter = Class.create({
560: var Template = Class.create({
997: var Hash = Class.create(Enumerable, (function() {
1094: var ObjectRange = Class.create(Enumerable, {
1168: Ajax.Base = Class.create({
1190: Ajax.Request = Class.create(Ajax.Base, {
1363: Ajax.Response = Class.create({
1437: Ajax.Updater = Class.create(Ajax.Request, {
1473: Ajax.PeriodicalUpdater = Class.create(Ajax.Base, {
1681:     $H({'id': 'id', 'className': 'class'}).each(function(pair) {
2721: /* Portions of the Selector class are derived from Jack Slocum's DomQuery,
2725: var Selector = Class.create({
2913:     className:    "[contains(concat(' ', @class, ' '), ' #{1} ')]",
3213:       var needle = ' ' + className + ' ';
3217:         if (nodeClassName == className || (' ' + nodeClassName + ' ').include(needle))
3704: Abstract.TimedObserver = Class.create(PeriodicalExecuter, {
3721: Form.Element.Observer = Class.create(Abstract.TimedObserver, {
3727: Form.Observer = Class.create(Abstract.TimedObserver, {
3735: Abstract.EventObserver = Class.create({
3774: Form.Element.EventObserver = Class.create(Abstract.EventObserver, {
3780: Form.EventObserver = Class.create(Abstract.EventObserver, {
4252:     return name.blank() ? null : "[contains(concat(' ', @class, ' '), ' " + name + " ')]";
4285: Element.ClassNames = Class.create();
55:     klass.superclass = parent;
61:       klass.prototype = new subclass;
79:     var ancestor   = this.superclass && this.superclass.prototype;
1831:     return new Element.ClassNames(element);
1836:     var elementClassName = element.className;
1837:     return (elementClassName.length > 0 && (elementClassName == className ||
1838:       new RegExp("(^|\\s)" + className + "(\\s|$)").test(elementClassName)));
1843:     if (!element.hasClassName(className))
1844:       element.className += (element.className ? ' ' : '') + className;
1850:     element.className = element.className.replace(
1851:       new RegExp("(^|\\s+)" + className + "(\\s+|$)"), ' ').strip();
1857:     return element[element.hasClassName(className) ?
1858:       'removeClassName' : 'addClassName'](className);
2676:       var klass = findDOMClass(tag);
3007:     className:    'n = h.className(n, r, "#{1}", c);    c = false;',
3035:     className:    /^\.([\w\-\*]+)(\b|$)/,
3048:     className: function(element, matches) {
3206:     className: function(nodes, root, className, combinator) {
3208:       return Selector.handlers.byClassName(nodes, root, className);
3211:     byClassName: function(nodes, root, className) {
3215:         nodeClassName = node.className;
4256:   function(element, className) {
4257:     className = className.toString().strip();
4258:     var cond = /\s/.test(className) ? $w(className).map(iter).join('') : iter(className);
4260:   } : function(element, className) {
4261:     className = className.toString().strip();
4262:     var elements = [], classNames = (/\s/.test(className) ? $w(className) : null);
4263:     if (!classNames && !className) return elements;
4266:     className = ' ' + className + ' ';
4269:       if (child.className && (cn = ' ' + child.className + ' ') && (cn.include(className) ||
4270:           (classNames && classNames.all(function(name) {
4278:   return function(className, parentElement) {
4279:     return $(parentElement || document.body).getElementsByClassName(className);
4292:     this.element.className.split(/\s+/).select(function(name) {
4297:   set: function(className) {
4298:     this.element.className = className;
4301:   add: function(classNameToAdd) {
4302:     if (this.include(classNameToAdd)) return;
4303:     this.set($A(this).concat(classNameToAdd).join(' '));
4306:   remove: function(classNameToRemove) {
4307:     if (!this.include(classNameToRemove)) return;
4308:     this.set($A(this).without(classNameToRemove).join(' '));
4316: Object.extend(Element.ClassNames.prototype, Enumerable);
56:     klass.subclasses = [];
62:       parent.subclasses.push(klass);
3049:       return Element.hasClassName(element, matches[1]);
3214:       for (var i = 0, results = [], node, nodeClassName; node = nodes[i]; i++) {
3216:         if (nodeClassName.length == 0) continue;
4250: if (!document.getElementsByClassName) document.getElementsByClassName = function(instanceMethods){
4255:   instanceMethods.getElementsByClassName = Prototype.BrowserFeatures.XPath ?
chromium.googlesource.com/external/w3c/web-platform-tests:css/work-in-progress/gabriele/css-xml-dom/js/prototype.js:[master, ]
duplicate result
android.googlesource.com/mirror/superproject:platform/external/clang_35a/lib/Sema/AnalysisBasedWarnings.cpp:[master, ]
577:   const DeclRefExpr *Needle;
63:   class UnreachableCodeHandler : public reachable_code::Callback {
121: class LogicalErrorHandler : public CFGCallback {
192:         // Skip function calls which are qualified with a templated class.
572: /// ContainsReference - A visitor class to search for references to
573: /// a particular declaration (the needle) within any evaluated component of an
575: class ContainsReference : public EvaluatedExprVisitor<ContainsReference> {
580:   ContainsReference(ASTContext &Context, const DeclRefExpr *Needle)
582:       FoundReference(false), Needle(Needle) {}
593:     if (E == Needle)
885:   class FallthroughMapper : public RecursiveASTVisitor<FallthroughMapper> {
1331: class UninitValsDiagReporter : public UninitVariablesHandler {
1454: class ThreadSafetyReporter : public clang::thread_safety::ThreadSafetyHandler {
1629: class ConsumedWarningsHandler : public ConsumedWarningsHandlerBase {
229:   // templated classes.
712:     switch (Term ? Term->getStmtClass() : Stmt::DeclStmtClass) {
719:     case Stmt::IfStmtClass: {
729:     case Stmt::ConditionalOperatorClass: {
739:     case Stmt::BinaryOperatorClass: {
759:     case Stmt::WhileStmtClass:
766:     case Stmt::ForStmtClass:
776:     case Stmt::CXXForRangeStmtClass:
789:     case Stmt::DoStmtClass:
798:     case Stmt::CaseStmtClass:
803:     case Stmt::DefaultStmtClass:
1155:     switch (S->getStmtClass()) {
1156:     case Stmt::ForStmtClass:
1157:     case Stmt::WhileStmtClass:
1158:     case Stmt::CXXForRangeStmtClass:
1159:     case Stmt::ObjCForCollectionStmtClass:
1161:     case Stmt::DoStmtClass: {
1251:   // Classify the current code body for better warning text.
1254:   // FIXME: Should we use a common classification enum and the same set of
1291:     // Classify the weak object being accessed for better warning text.
1831:       .setAlwaysAdd(Stmt::BinaryOperatorClass)
1832:       .setAlwaysAdd(Stmt::CompoundAssignOperatorClass)
1833:       .setAlwaysAdd(Stmt::BlockExprClass)
1834:       .setAlwaysAdd(Stmt::CStyleCastExprClass)
1835:       .setAlwaysAdd(Stmt::DeclRefExprClass)
1836:       .setAlwaysAdd(Stmt::ImplicitCastExprClass)
1837:       .setAlwaysAdd(Stmt::UnaryOperatorClass)
1838:       .setAlwaysAdd(Stmt::AttributedStmtClass);
android.googlesource.com/platform/superproject:external/clang/lib/Sema/AnalysisBasedWarnings.cpp:[master, ]
591:   const DeclRefExpr *Needle;
62:   class UnreachableCodeHandler : public reachable_code::Callback {
121: class LogicalErrorHandler : public CFGCallback {
179:     // Skip function calls which are qualified with a templated class.
586: /// ContainsReference - A visitor class to search for references to
587: /// a particular declaration (the needle) within any evaluated component of an
589: class ContainsReference : public ConstEvaluatedExprVisitor<ContainsReference> {
596:   ContainsReference(ASTContext &Context, const DeclRefExpr *Needle)
597:     : Inherited(Context), FoundReference(false), Needle(Needle) {}
608:     if (E == Needle)
899:   class FallthroughMapper : public RecursiveASTVisitor<FallthroughMapper> {
1360: class UninitValsDiagReporter : public UninitVariablesHandler {
1472: class ThreadSafetyReporter : public clang::threadSafety::ThreadSafetyHandler {
1742: class ConsumedWarningsHandler : public ConsumedWarningsHandlerBase {
259:   // templated classes.
727:     switch (Term ? Term->getStmtClass() : Stmt::DeclStmtClass) {
734:     case Stmt::IfStmtClass: {
744:     case Stmt::ConditionalOperatorClass: {
754:     case Stmt::BinaryOperatorClass: {
774:     case Stmt::WhileStmtClass:
781:     case Stmt::ForStmtClass:
791:     case Stmt::CXXForRangeStmtClass:
804:     case Stmt::DoStmtClass:
813:     case Stmt::CaseStmtClass:
818:     case Stmt::DefaultStmtClass:
1182:     switch (S->getStmtClass()) {
1183:     case Stmt::ForStmtClass:
1184:     case Stmt::WhileStmtClass:
1185:     case Stmt::CXXForRangeStmtClass:
1186:     case Stmt::ObjCForCollectionStmtClass:
1188:     case Stmt::DoStmtClass: {
1277:   // Classify the current code body for better warning text.
1280:   // FIXME: Should we use a common classification enum and the same set of
1315:     // Classify the weak object being accessed for better warning text.
1935:       .setAlwaysAdd(Stmt::BinaryOperatorClass)
1936:       .setAlwaysAdd(Stmt::CompoundAssignOperatorClass)
1937:       .setAlwaysAdd(Stmt::BlockExprClass)
1938:       .setAlwaysAdd(Stmt::CStyleCastExprClass)
1939:       .setAlwaysAdd(Stmt::DeclRefExprClass)
1940:       .setAlwaysAdd(Stmt::ImplicitCastExprClass)
1941:       .setAlwaysAdd(Stmt::UnaryOperatorClass)
1942:       .setAlwaysAdd(Stmt::AttributedStmtClass);
android.googlesource.com/platform/external/chromium:chrome/browser/sync/syncable/syncable.h:[master, ]
1002:     EntryKernel needle;
33: class DictionaryValue;
37: class ReadTransaction;
38: class WriteNode;
39: class ReadNode;
43: class DirectoryChangeListener;
44: class Entry;
48: class DirectoryBackingStore;
179: class BaseTransaction;
180: class WriteTransaction;
181: class ReadTransaction;
182: class Directory;
183: class ScopedDirLookup;
222: // The EntryKernel class contains the actual data for an entry.
347: class Entry {
348:   friend class Directory;
438:   friend class sync_api::ReadNode;
460: class MutableEntry : public Entry {
461:   friend class WriteTransaction;
462:   friend class Directory;
520:   friend class sync_api::WriteNode;
541: class LessParentIdAndHandle;
543: class LessField;
544: class LessEntryMetaHandles {
567: // index, the traits are grouped into a class called an Indexer which
606:   class Comparator {
659: class ScopedKernelLock;
660: class IdFilter;
661: class DirectoryManager;
663: class Directory {
664:   friend class BaseTransaction;
665:   friend class Entry;
666:   friend class MutableEntry;
667:   friend class ReadTransaction;
668:   friend class ReadTransactionWithoutDB;
669:   friend class ScopedKernelLock;
670:   friend class ScopedKernelUnlock;
671:   friend class WriteTransaction;
672:   friend class SyncableDirectoryTest;
682:   class EventListenerHookup;
828:   template <class T> void TestAndSet(T* kernel_data, const T* data_to_set);
1001:     // look something up in an index.  Needle in haystack metaphor.
1071: class ScopedKernelLock {
1082: class BaseTransaction {
1083:   friend class Entry;
1118: class ReadTransaction : public BaseTransaction {
1128:   friend class sync_api::ReadTransaction;
1135: class WriteTransaction : public BaseTransaction {
1136:   friend class MutableEntry;
647: // friend classes.  The in-memory indices are protected against
android.googlesource.com/platform/external/webkit:PerformanceTests/SunSpider/tests/parse-only/prototype-1.6.0.3.js:[master, ]
duplicate result
github.com/fuchsia-mirror/third_party-ffmpeg:libavfilter/vf_find_rect.c:[master, ]
35:     AVClass *class;
42:     AVFrame *needle_frame[MAX_MIPMAPS];
59: AVFILTER_DEFINE_CLASS(find_rect);
171:             float score = compare(foc->haystack_frame[pass], foc->needle_frame[pass], x, y);
234:         av_frame_free(&foc->needle_frame[i]);
267:     foc->needle_frame[0] = av_frame_clone(foc->obj_frame);
269:         foc->needle_frame[i] = downscale(foc->needle_frame[i-1]);
270:         if (!foc->needle_frame[i])
304:     .priv_class      = &find_rect_class,
android.googlesource.com/mirror/superproject:platform/external/chromium_org/third_party/WebKit/PerformanceTests/SunSpider/tests/parse-only/prototype-1.6.0.3.js:[master, ]
duplicate result
github.com/fuchsia-mirror/third_party-cmake:Source/cmTarget.cxx:[master, ]
565:   const cmSourceFileLocation& Needle;
581:   const cmSourceFileLocation& Needle;
160: class cmTargetInternals
567:   LocationMatcher(const cmSourceFileLocation& needle)
568:     : Needle(needle)
574:     return loc.Matches(this->Needle);
584:   TargetPropertyEntryFinder(const cmSourceFileLocation& needle)
585:     : Needle(needle)
595:                    CreateLocation(this->Needle.GetMakefile()));
598:                         LocationMatcher(this->Needle)) != locations.end();
github.com/pagespeed/page-speed:firefox_addon/branches/ff5/src/pagespeed_firefox/js/pagespeed/cssEfficiencyChecker.js:[master, ]
141:   CLASS: 1,
34:  *     is one of {@code ID}, {@code CLASS}, {@code TAG}, or {@code UNIVERSAL}.
40:  *       <li>{@code CLASS} and {@code ID} selectors are given a cost of 1
42:  *         class or id.
58:  *       <li>Selectors that have an id plus a class or tag are multiplied by
61:  *       <li>Selectors that have a class and a tag are also multiplied
155:   case PAGESPEED.SelectorKey.CLASS:
156:     return 'Class';
174:  * a.foo, a b, #my-class { color:red; } -> 'a.foo, a b, #my-class'
200:  * 'a.foo, a b, #my-class' -> ['a.foo','a b','#my-class']
219:  * for the selector. See the class documentation for more information.
300:     // Selectors can only be overly qualified if they have an ID or CLASS
302:         selectorKey == PAGESPEED.SelectorKey.CLASS) {
311:       // Selectors with an ID shouldn't have CLASS refiners
316:             new PAGESPEED.Cost(2, 'ID overly qualified with class'));
320:       // Selectors with a CLASS shouldn't have ID refiners
321:       if (selectorKey == PAGESPEED.SelectorKey.CLASS) {
325:             new PAGESPEED.Cost(2, 'class overly qualified with ID'));
357:   // Look for CLASS and ID refiners
359:     selectorType = PAGESPEED.SelectorKey.CLASS;
439:   // a.class
59:  *         2 because they are needlessly requiring extra work -- the id by
71:  *     different tags, classes, and ids.
132:  * key is how Firefox classifies selectors in order to make matching more
github.com/yeoman/generator-angular:route/index.js:[master, ]
63:     needle: '.otherwise',
66:       "  controller: '" + this.classedName + "Ctrl'" + (coffee ? "" : ","),
github.com/pagespeed/page-speed:firefox_addon/branches/chromium_update4/src/pagespeed_firefox/js/pagespeed/cssEfficiencyChecker.js:[master, ]
duplicate result
android.googlesource.com/mirror/superproject:platform/superproject/external/clang/lib/Sema/AnalysisBasedWarnings.cpp:[master, ]
duplicate result
android.googlesource.com/mirror/superproject:platform/external/chromium/chrome/browser/sync/syncable/syncable.h:[master, ]
duplicate result
github.com/google/rekall:rekall-core/rekall/scan.py:[master, ]
163:     needle = None
164:     needle_offset = None
539:     needles = []
41:     __metaclass__ = registry.MetaclassRegistry
356:     __metaclass__ = registry.MetaclassRegistry
31: class ScannerCheck(object):
32:     """A scanner check is a special class which is invoked on an AS to check
38:     This class is the base class for all checks.
55:         """Is the needle found at 'offset'?
59:             checked for the needle.
89: class MultiStringFinderCheck(ScannerCheck):
160: class StringCheck(ScannerCheck):
166:     def __init__(self, needle=None, needle_offset=0, **kwargs):
168:         self.needle = needle
169:         self.needle_offset = needle_offset
173:         buffer_offset = buffer_as.get_buffer_offset(offset) + self.needle_offset
174:         if buffer_as.data.startswith(self.needle, buffer_offset):
175:             return self.needle
178:         # Search the rest of the buffer for the needle.
179:         buffer_offset = buffer_as.get_buffer_offset(offset) + self.needle_offset
180:         dindex = buffer_as.data.find(self.needle, buffer_offset + 1)
188: class RegexCheck(ScannerCheck):
203: class _Padding(object):
209: class _BufferFragments(object):
251: class BufferASGenerator(object):
353: class BaseScanner(object):
354:     """Base class for all scanners."""
388:         for class_name, args in self.checks:
389:             check = ScannerCheck.classes[class_name](
490: class FastStructScanner(BaseScanner):
531:             yield ("StringCheck", dict(needle=expected_bytes,
532:                                        needle_offset=rel_offset + array_offset))
535: class MultiStringScanner(BaseScanner):
552:                 needle=self.needles[0])
568: class PointerScanner(BaseScanner):
602: class ScannerGroup(BaseScanner):
639: class DiscontigScannerGroup(ScannerGroup):
652: class DebugChecker(ScannerCheck):
92:     def __init__(self, needles=None, **kwargs):
96:           needles: A list of strings we search for.
99:           RuntimeError: No needles provided.
105:         if not needles:
106:             raise RuntimeError("No needles provided to search.")
110:         if max([len(x) for x in needles]) > 50:
113:         tree = acora.AcoraBuilder(*needles)
538:     # Override with the needles to check for.
541:     def __init__(self, needles=None, **kwargs):
543:         if needles is not None:
544:             self.needles = needles
549:         if len(needles) == 1:
556:                 needles=self.needles)
586:         self.needles = []
594:             self.needles.append(tmp.obj_vm.read(0, tmp.obj_size))
596:         # The common string between all the needles.
598:             ("MultiStringFinderCheck", dict(needles=self.needles)),
chromium.googlesource.com/experimental/src-pruned-refs:chrome/test/data/dromaeo/lib/prototype.js:[master, ]
duplicate result
github.com/GoogleChrome/web-audio-samples:samples/audio/box2d-js/lib/prototype-1.6.0.2.js:[gh-pages, ]
duplicate result
android.googlesource.com/mirror/superproject:platform/external/webkit/PerformanceTests/SunSpider/tests/parse-only/prototype-1.6.0.3.js:[master, ]
duplicate result
android.googlesource.com/platform/external/clang_35a:lib/Sema/AnalysisBasedWarnings.cpp:[master, ]
duplicate result
chromium.googlesource.com/native_client/pnacl-clang:lib/Sema/AnalysisBasedWarnings.cpp:[master, ]
579:   const DeclRefExpr *Needle;
63:   class UnreachableCodeHandler : public reachable_code::Callback {
122: class LogicalErrorHandler : public CFGCallback {
203:         // Skip function calls which are qualified with a templated class.
574: /// ContainsReference - A visitor class to search for references to
575: /// a particular declaration (the needle) within any evaluated component of an
577: class ContainsReference : public EvaluatedExprVisitor<ContainsReference> {
582:   ContainsReference(ASTContext &Context, const DeclRefExpr *Needle)
584:       FoundReference(false), Needle(Needle) {}
595:     if (E == Needle)
888:   class FallthroughMapper : public RecursiveASTVisitor<FallthroughMapper> {
1325: class UninitValsDiagReporter : public UninitVariablesHandler {
1442: class ThreadSafetyReporter : public clang::threadSafety::ThreadSafetyHandler {
1713: class ConsumedWarningsHandler : public ConsumedWarningsHandlerBase {
240:   // templated classes.
715:     switch (Term ? Term->getStmtClass() : Stmt::DeclStmtClass) {
722:     case Stmt::IfStmtClass: {
732:     case Stmt::ConditionalOperatorClass: {
742:     case Stmt::BinaryOperatorClass: {
762:     case Stmt::WhileStmtClass:
769:     case Stmt::ForStmtClass:
779:     case Stmt::CXXForRangeStmtClass:
792:     case Stmt::DoStmtClass:
801:     case Stmt::CaseStmtClass:
806:     case Stmt::DefaultStmtClass:
1152:     switch (S->getStmtClass()) {
1153:     case Stmt::ForStmtClass:
1154:     case Stmt::WhileStmtClass:
1155:     case Stmt::CXXForRangeStmtClass:
1156:     case Stmt::ObjCForCollectionStmtClass:
1158:     case Stmt::DoStmtClass: {
1248:   // Classify the current code body for better warning text.
1251:   // FIXME: Should we use a common classification enum and the same set of
1286:     // Classify the weak object being accessed for better warning text.
1903:       .setAlwaysAdd(Stmt::BinaryOperatorClass)
1904:       .setAlwaysAdd(Stmt::CompoundAssignOperatorClass)
1905:       .setAlwaysAdd(Stmt::BlockExprClass)
1906:       .setAlwaysAdd(Stmt::CStyleCastExprClass)
1907:       .setAlwaysAdd(Stmt::DeclRefExprClass)
1908:       .setAlwaysAdd(Stmt::ImplicitCastExprClass)
1909:       .setAlwaysAdd(Stmt::UnaryOperatorClass)
1910:       .setAlwaysAdd(Stmt::AttributedStmtClass);
android.googlesource.com/platform/external/chromium_org/third_party/WebKit:PerformanceTests/SunSpider/tests/parse-only/prototype-1.6.0.3.js:[master, ]
duplicate result
android.googlesource.com/platform/external/clang:lib/Sema/AnalysisBasedWarnings.cpp:[master, ]
duplicate result
github.com/fuchsia-mirror/third_party-clang:lib/Sema/AnalysisBasedWarnings.cpp:[master, ]
618:   const DeclRefExpr *Needle;
57:   class UnreachableCodeHandler : public reachable_code::Callback {
126: class LogicalErrorHandler : public CFGCallback {
184:     // Skip function calls which are qualified with a templated class.
613: /// ContainsReference - A visitor class to search for references to
614: /// a particular declaration (the needle) within any evaluated component of an
616: class ContainsReference : public ConstEvaluatedExprVisitor<ContainsReference> {
623:   ContainsReference(ASTContext &Context, const DeclRefExpr *Needle)
624:     : Inherited(Context), FoundReference(false), Needle(Needle) {}
635:     if (E == Needle)
926:   class FallthroughMapper : public RecursiveASTVisitor<FallthroughMapper> {
1396: class UninitValsDiagReporter : public UninitVariablesHandler {
1508: class ThreadSafetyReporter : public clang::threadSafety::ThreadSafetyHandler {
1778: class ConsumedWarningsHandler : public ConsumedWarningsHandlerBase {
264:   // templated classes.
754:     switch (Term ? Term->getStmtClass() : Stmt::DeclStmtClass) {
761:     case Stmt::IfStmtClass: {
771:     case Stmt::ConditionalOperatorClass: {
781:     case Stmt::BinaryOperatorClass: {
801:     case Stmt::WhileStmtClass:
808:     case Stmt::ForStmtClass:
818:     case Stmt::CXXForRangeStmtClass:
831:     case Stmt::DoStmtClass:
840:     case Stmt::CaseStmtClass:
845:     case Stmt::DefaultStmtClass:
1218:     switch (S->getStmtClass()) {
1219:     case Stmt::ForStmtClass:
1220:     case Stmt::WhileStmtClass:
1221:     case Stmt::CXXForRangeStmtClass:
1222:     case Stmt::ObjCForCollectionStmtClass:
1224:     case Stmt::DoStmtClass: {
1313:   // Classify the current code body for better warning text.
1316:   // FIXME: Should we use a common classification enum and the same set of
1351:     // Classify the weak object being accessed for better warning text.
1971:       .setAlwaysAdd(Stmt::BinaryOperatorClass)
1972:       .setAlwaysAdd(Stmt::CompoundAssignOperatorClass)
1973:       .setAlwaysAdd(Stmt::BlockExprClass)
1974:       .setAlwaysAdd(Stmt::CStyleCastExprClass)
1975:       .setAlwaysAdd(Stmt::DeclRefExprClass)
1976:       .setAlwaysAdd(Stmt::ImplicitCastExprClass)
1977:       .setAlwaysAdd(Stmt::UnaryOperatorClass)
1978:       .setAlwaysAdd(Stmt::AttributedStmtClass);
github.com/llvm-mirror/clang:lib/Sema/AnalysisBasedWarnings.cpp:[master, ]
622:   const DeclRefExpr *Needle;
57:   class UnreachableCodeHandler : public reachable_code::Callback {
126: class LogicalErrorHandler : public CFGCallback {
184:     // Skip function calls which are qualified with a templated class.
617: /// ContainsReference - A visitor class to search for references to
618: /// a particular declaration (the needle) within any evaluated component of an
620: class ContainsReference : public ConstEvaluatedExprVisitor<ContainsReference> {
627:   ContainsReference(ASTContext &Context, const DeclRefExpr *Needle)
628:     : Inherited(Context), FoundReference(false), Needle(Needle) {}
639:     if (E == Needle)
930:   class FallthroughMapper : public RecursiveASTVisitor<FallthroughMapper> {
1400: class UninitValsDiagReporter : public UninitVariablesHandler {
1512: class ThreadSafetyReporter : public clang::threadSafety::ThreadSafetyHandler {
1782: class ConsumedWarningsHandler : public ConsumedWarningsHandlerBase {
264:   // templated classes.
758:     switch (Term ? Term->getStmtClass() : Stmt::DeclStmtClass) {
765:     case Stmt::IfStmtClass: {
775:     case Stmt::ConditionalOperatorClass: {
785:     case Stmt::BinaryOperatorClass: {
805:     case Stmt::WhileStmtClass:
812:     case Stmt::ForStmtClass:
822:     case Stmt::CXXForRangeStmtClass:
835:     case Stmt::DoStmtClass:
844:     case Stmt::CaseStmtClass:
849:     case Stmt::DefaultStmtClass:
1222:     switch (S->getStmtClass()) {
1223:     case Stmt::ForStmtClass:
1224:     case Stmt::WhileStmtClass:
1225:     case Stmt::CXXForRangeStmtClass:
1226:     case Stmt::ObjCForCollectionStmtClass:
1228:     case Stmt::DoStmtClass: {
1317:   // Classify the current code body for better warning text.
1320:   // FIXME: Should we use a common classification enum and the same set of
1355:     // Classify the weak object being accessed for better warning text.
1975:       .setAlwaysAdd(Stmt::BinaryOperatorClass)
1976:       .setAlwaysAdd(Stmt::CompoundAssignOperatorClass)
1977:       .setAlwaysAdd(Stmt::BlockExprClass)
1978:       .setAlwaysAdd(Stmt::CStyleCastExprClass)
1979:       .setAlwaysAdd(Stmt::DeclRefExprClass)
1980:       .setAlwaysAdd(Stmt::ImplicitCastExprClass)
1981:       .setAlwaysAdd(Stmt::UnaryOperatorClass)
1982:       .setAlwaysAdd(Stmt::AttributedStmtClass);
github.com/pagespeed/page-speed:firefox_addon/tags/page-speed-1.7.1.0/src/pagespeed_firefox/js/pagespeed/cssEfficiencyChecker.js:[master, ]
141:   CLASS: 1,
34:  *     is one of {@code ID}, {@code CLASS}, {@code TAG}, or {@code UNIVERSAL}.
40:  *       <li>{@code CLASS} and {@code ID} selectors are given a cost of 1
42:  *         class or id.
58:  *       <li>Selectors that have an id plus a class or tag are multiplied by
61:  *       <li>Selectors that have a class and a tag are also multiplied
155:   case PAGESPEED.SelectorKey.CLASS:
156:     return 'Class';
174:  * a.foo, a b, #my-class { color:red; } -> 'a.foo, a b, #my-class'
200:  * 'a.foo, a b, #my-class' -> ['a.foo','a b','#my-class']
219:  * for the selector. See the class documentation for more information.
300:     // Selectors can only be overly qualified if they have an ID or CLASS
302:         selectorKey == PAGESPEED.SelectorKey.CLASS) {
311:       // Selectors with an ID shouldn't have CLASS refiners
316:             new PAGESPEED.Cost(2, 'ID overly qualified with class'));
320:       // Selectors with a CLASS shouldn't have ID refiners
321:       if (selectorKey == PAGESPEED.SelectorKey.CLASS) {
325:             new PAGESPEED.Cost(2, 'class overly qualified with ID'));
357:   // Look for CLASS and ID refiners
359:     selectorType = PAGESPEED.SelectorKey.CLASS;
439:   // a.class
59:  *         2 because they are needlessly requiring extra work -- the id by
71:  *     different tags, classes, and ids.
132:  * key is how Firefox classifies selectors in order to make matching more
chromium.googlesource.com/external/w3c/web-platform-tests:conformance-checkers/html-aria/_functional/tree/js/prototype.js:[master, ]
43: var Class = {
2292:         'class': 'className',
58:       var subclass = function() { };
59:       subclass.prototype = parent.prototype;
1820:   classNames: function(element) {
2167:       className: 'class',
2642:   function findDOMClass(tagName) {
4150: Element.ClassNames.prototype = {
1824:   hasClassName: function(element, className) {
1831:   addClassName: function(element, className) {
1838:   removeClassName: function(element, className) {
1845:   toggleClassName: function(element, className) {
53:     Object.extend(klass, Class.Methods);
76: Class.Methods = {
287: var PeriodicalExecuter = Class.create({
551: var Template = Class.create({
986: var Hash = Class.create(Enumerable, (function() {
1102: var ObjectRange = Class.create(Enumerable, {
1176: Ajax.Base = Class.create({
1195: Ajax.Request = Class.create(Ajax.Base, {
1359: Ajax.Response = Class.create({
1430: Ajax.Updater = Class.create(Ajax.Request, {
1470: Ajax.PeriodicalUpdater = Class.create(Ajax.Base, {
1671:     $H({'id': 'id', 'className': 'class'}).each(function(pair) {
2712: /* Portions of the Selector class are derived from Jack Slocum’s DomQuery,
2716: var Selector = Class.create({
2845:     className:    "[contains(concat(' ', @class, ' '), ' #{1} ')]",
3139:       var needle = ' ' + className + ' ';
3143:         if (nodeClassName == className || (' ' + nodeClassName + ' ').include(needle))
3601: Abstract.TimedObserver = Class.create(PeriodicalExecuter, {
3618: Form.Element.Observer = Class.create(Abstract.TimedObserver, {
3624: Form.Observer = Class.create(Abstract.TimedObserver, {
3632: Abstract.EventObserver = Class.create({
3671: Form.Element.EventObserver = Class.create(Abstract.EventObserver, {
3677: Form.EventObserver = Class.create(Abstract.EventObserver, {
4116:     return name.blank() ? null : "[contains(concat(' ', @class, ' '), ' " + name + " ')]";
4149: Element.ClassNames = Class.create();
54:     klass.superclass = parent;
60:       klass.prototype = new subclass;
78:     var ancestor   = this.superclass && this.superclass.prototype;
1821:     return new Element.ClassNames(element);
1826:     var elementClassName = element.className;
1827:     return (elementClassName.length > 0 && (elementClassName == className ||
1828:       new RegExp("(^|\\s)" + className + "(\\s|$)").test(elementClassName)));
1833:     if (!element.hasClassName(className))
1834:       element.className += (element.className ? ' ' : '') + className;
1840:     element.className = element.className.replace(
1841:       new RegExp("(^|\\s+)" + className + "(\\s+|$)"), ' ').strip();
1847:     return element[element.hasClassName(className) ?
1848:       'removeClassName' : 'addClassName'](className);
2674:       var klass = findDOMClass(tag);
2935:     className:    'n = h.className(n, r, "#{1}", c); c = false;',
2963:     className:    /^\.([\w\-\*]+)(\b|$)/,
2975:     className: function(element, matches) {
3132:     className: function(nodes, root, className, combinator) {
3134:       return Selector.handlers.byClassName(nodes, root, className);
3137:     byClassName: function(nodes, root, className) {
3141:         nodeClassName = node.className;
4120:   function(element, className) {
4121:     className = className.toString().strip();
4122:     var cond = /\s/.test(className) ? $w(className).map(iter).join('') : iter(className);
4124:   } : function(element, className) {
4125:     className = className.toString().strip();
4126:     var elements = [], classNames = (/\s/.test(className) ? $w(className) : null);
4127:     if (!classNames && !className) return elements;
4130:     className = ' ' + className + ' ';
4133:       if (child.className && (cn = ' ' + child.className + ' ') && (cn.include(className) ||
4134:           (classNames && classNames.all(function(name) {
4142:   return function(className, parentElement) {
4143:     return $(parentElement || document.body).getElementsByClassName(className);
4156:     this.element.className.split(/\s+/).select(function(name) {
4161:   set: function(className) {
4162:     this.element.className = className;
4165:   add: function(classNameToAdd) {
4166:     if (this.include(classNameToAdd)) return;
4167:     this.set($A(this).concat(classNameToAdd).join(' '));
4170:   remove: function(classNameToRemove) {
4171:     if (!this.include(classNameToRemove)) return;
4172:     this.set($A(this).without(classNameToRemove).join(' '));
4180: Object.extend(Element.ClassNames.prototype, Enumerable);
55:     klass.subclasses = [];
61:       parent.subclasses.push(klass);
2976:       return Element.hasClassName(element, matches[1]);
3140:       for (var i = 0, results = [], node, nodeClassName; node = nodes[i]; i++) {
3142:         if (nodeClassName.length == 0) continue;
4114: if (!document.getElementsByClassName) document.getElementsByClassName = function(instanceMethods){
4119:   instanceMethods.getElementsByClassName = Prototype.BrowserFeatures.XPath ?
github.com/pagespeed/page-speed:firefox_addon/tags/page-speed-1.12.9.1/src/pagespeed_firefox/js/pagespeed/cssEfficiencyChecker.js:[master, ]
duplicate result
android.googlesource.com/mirror/superproject:platform/external/clang/lib/Sema/AnalysisBasedWarnings.cpp:[master, ]
duplicate result
github.com/pagespeed/page-speed:firefox_addon/tags/page-speed-1.12.9.0/src/pagespeed_firefox/js/pagespeed/cssEfficiencyChecker.js:[master, ]
duplicate result
github.com/pagespeed/page-speed:firefox_addon/tags/page-speed-1.7.0.0/src/pagespeed_firefox/js/pagespeed/cssEfficiencyChecker.js:[master, ]
duplicate result
chromium.googlesource.com/chromium/deps/xulrunner-sdk:win/bin/modules/Microformats.js:[master, ]
1237:     "class" : {
1442:     "class" : {
1155:   className: "adr",
1221:   className: "vcard",
1433:   className: "vevent",
1641:   className: "geo",
31:     function isAncestor(haystack, needle) {
32:       var parent = needle;
36:         if (parent == needle.parentNode) {
186:         xpathExpression += "contains(concat(' ', @class, ' '), ' " + Microformats[mfname].className + " ')";
692:       /* is a class based microformat and the passed in node is not the */
708:       /* Query the correct set of nodes (rel or class) based on the setting */
734:             xpathExpression += "contains(concat(' ', @class, ' '), ' " + Microformats[Microformats.list[j]].className + " ')";
778:         /* If we didn't find any class nodes, check to see if this property */
791:      * the innerHTML and the class name.
1038:       xpathExpression = ".//*[contains(concat(' ', @class, ' '), ' " + className + " ')]";
1098:     var classValue = node.getAttribute("class");
1179:                                               "contains(concat(' ', @class, ' '), ' post-office-box ')" +
1180:                                               " or contains(concat(' ', @class, ' '), ' street-address ')" +
1181:                                               " or contains(concat(' ', @class, ' '), ' extended-address ')" +
1182:                                               " or contains(concat(' ', @class, ' '), ' locality ')" +
1183:                                               " or contains(concat(' ', @class, ' '), ' region ')" +
1184:                                               " or contains(concat(' ', @class, ' '), ' postal-code ')" +
1185:                                               " or contains(concat(' ', @class, ' '), ' country-name')" +
1614:     var xpathExpression = "ancestor::*[contains(concat(' ', @class, ' '), ' vcard ')]";
1623:     xpathExpression = "ancestor::*[contains(concat(' ', @class, ' '), ' vevent ')]";
65:     if (Microformats[name].className) {
67:                                         Microformats[name].className);
71:         var altClass = Microformats.getElementsByClassName(rootElement, Microformats[name].alternateClassName);
72:         if (altClass.length > 0) {
148:       if (Microformats[i].className) {
149:         if (Microformats.matchClass(node, Microformats[i].className)) {
185:       if (Microformats[mfname].className) {
220:         if (Microformats[i].className) {
221:           if (Microformats.matchClass(node, Microformats[i].className)) {
348:         if (!Microformats.matchClass(propnode, "value")) {
434:       if (Microformats.matchClass(propnode, "value")) {
464:         if (Microformats.matchClass(propnode, "value")) {
599:           if (!Microformats.matchClass(in_node, Microformats[microformat].className)) {
605:       if ((Microformats[microformat].className) && in_node.ownerDocument) {
696:       if (!in_mfnode.origNode && Microformats[mfname].className && in_mfnode.ownerDocument) {
728:           if (Microformats[Microformats.list[j]].className) {
826:               tempNode.className = headerNode.className;
1017:    * Retrieve elements matching all classes listed in a space-separated string.
1021:    * @param  className        A space separated list of classenames
1025:   getElementsByClassName: function getElementsByClassName(rootNode, className)
1031:       var col = rootNode.getElementsByClassName(className);
1047:       className = className.replace(/\-/g, "\\-");
1050:         if (elements[i].className.match("(^|\\s)" + className + "(\\s|$)")) {
1097:   matchClass: function matchClass(node, className) {
1099:     return (classValue && classValue.match("(^|\\s)" + className + "(\\s|$)"));
1720:           var ioService = Components.classes["@mozilla.org/network/io-service;1"].
66:       microformatNodes = Microformats.getElementsByClassName(rootElement,
68:       /* alternateClassName is for cases where a parent microformat is inferred by the children */
69:       /* If we find alternateClassName, the entire document becomes the microformat */
70:       if ((microformatNodes.length == 0) && Microformats[name].alternateClassName) {
323:         var values = Microformats.getElementsByClassName(propnode, "value");
640:             subpropnodes = Microformats.getElementsByClassName(propnode, subpropname);
714:         propnodes = Microformats.getElementsByClassName(mfnode, propname);
800:       var includes = Microformats.getElementsByClassName(in_mfnode, "include");
805:           includes = Microformats.getElementsByClassName(mfnode, "include");
1029:     if ((rootNode.ownerDocument || rootNode).getElementsByClassName) {
1030:     /* Firefox 3 - native getElementsByClassName */
1207:     var fns = Microformats.getElementsByClassName(this.node, "fn");
1416:     var summaries = Microformats.getElementsByClassName(this.node, "summary");
chromium.googlesource.com/ios-chromium-mirror:third_party/WebKit/PerformanceTests/SunSpider/tests/parse-only/prototype-1.6.0.3.js:[master, ]
duplicate result
chromium.googlesource.com/experimental/chromium/src:third_party/WebKit/PerformanceTests/SunSpider/tests/parse-only/prototype-1.6.0.3.js:[master, ]
duplicate result
github.com/hanwen/artisjokke:needle2d/needle-inserter.hh:[master, ]
6: #define NEEDLE_INSERTER
13: class Needle_inserter : public Deformation_hook
29:   Link_array<Node> needle_;
36:   Array<Vector2> needle_params_;
2:   declare Needle_inserter
5: #ifndef NEEDLE_INSERTER
44:   Auto_needle_insert * auto_insert_;
49:   void dump_needle_forces (const char *);
54:   Needle_inserter (Maubach_tree*, Deformation_state*);
55:   void move_needle (Vector2 h, Vector2 t);
58:   void auto_needle_insert ();
61:   void refine_around_needle_tip (Vector2,Vector2);
64:   void print_needle ();  
github.com/hanwen/artisjokke:needle2d/artisjokke-drawer2.hh:[master, ]
12:   Needle_inserter * needle_inserter_;
6: #include "needle-inserter.hh"
8: class Artisjokke_drawer2 : public Artisjokke_drawer
18:   virtual void set_needle ();
20:   virtual void draw_needle ();
chromium.googlesource.com/chromium/src/codesearch:v8/src/mips64/constants-mips64.h:[master, ]
605:   CLASS_S = ((3U << 3) + 3),
631:   CLASS_D = ((3U << 3) + 3),
798:   FCLASS = (0U << 17),
171: class Registers {
193: class FPURegisters {
212: class MSARegisters {
378:   COP1 = ((2U << 3) + 1) << kOpcodeShift,  // Coprocessor 1 class.
1154: enum class MaxMinKind : int { kMin = 0, kMax = 1 };
1205: class InstructionBase {
1380: template <class T>
1381: class InstructionGetters : public T {
1658: class Instruction : public InstructionGetters<InstructionBase> {
1662:   // to allocate or create instances of class Instruction.
1669:   // We need to prevent the creation of instances of class Instruction.
1809: template <class P>
1839: template <class P>
1860: template <class T>
91: // Defines constants and accessor classes to assemble, disassemble and
1681: // TODO(plind): find all usages and remove the needless instructions for n64.
chromium.googlesource.com/native_client/nacl-toolchain:gdb/sim/common/sim-fpu.h:[master, ]
89: } sim_fpu_class;
83:   sim_fpu_class_zero,
84:   sim_fpu_class_snan,
85:   sim_fpu_class_qnan,
86:   sim_fpu_class_number,
87:   sim_fpu_class_denorm,
88:   sim_fpu_class_infinity,
92:   sim_fpu_class class;
346: /* General number class and comparison operators.
46:    Needless to say the results, while better than for a packed 64 bit
297: /* Specific number classes.
github.com/google/mysql-protobuf:unittest/gunit/item_like-t.cc:[mysql-5.7.9, ]
104:   const char *m_needle;
121:   const char *m_needle;
124: static const char *needles[] = {
218: static const char* falseNeedles[] = {
25: #include "sql_class.h"
39: class ItemLikeTest : public ::testing::Test
60:   const char needle[]= "%ACAGGTGCTGGAGAGGATGCGGAGAAATAGGAACA%" ;
62:   Item_string *it_needle=
63:     new Item_string(STRING_WITH_LEN(needle), &my_charset_latin1);
65:     new Item_func_like(it_haystack, it_needle, it_escape, false);
78:   const char needle[]= "%CAAAACCACTATGAGATATCATCTCACACCAGTTA%";
79:   Item_string *it_needle=
80:     new Item_string(STRING_WITH_LEN(needle), &my_charset_latin1);
83:     new Item_func_like(it_haystack, it_needle, it_escape, false);
91: class ItemLikeTestP : public ::testing::TestWithParam<const char*>
97:     m_needle= GetParam();
108: class ItemFalseLikeTestP : public ::testing::TestWithParam<const char*>
114:     m_needle= GetParam();
207:   Item_string *it_needle=
208:     new Item_string(m_needle, strlen(m_needle), &my_charset_latin1);
213:     new Item_func_like(it_haystack, it_needle, it_escape, false);
296:   Item_string *it_needle=
297:     new Item_string(m_needle, strlen(m_needle), &my_charset_latin1);
302:     new Item_func_like(it_haystack, it_needle, it_escape, false);
200:                         ::testing::ValuesIn(needles));
199: INSTANTIATE_TEST_CASE_P(MoreNeedles, ItemLikeTestP,
203: TEST_P(ItemLikeTestP, MoreNeedlesTest)
289: INSTANTIATE_TEST_CASE_P(FalseNeedlesTest, ItemFalseLikeTestP,
290:                         ::testing::ValuesIn(falseNeedles));
292: TEST_P(ItemFalseLikeTestP,FalseNeedlesTest)
chromium.googlesource.com/chromiumos/third_party/gdb:sim/common/sim-fpu.h:[master, ]
89: } sim_fpu_class;
83:   sim_fpu_class_zero,
84:   sim_fpu_class_snan,
85:   sim_fpu_class_qnan,
86:   sim_fpu_class_number,
87:   sim_fpu_class_denorm,
88:   sim_fpu_class_infinity,
92:   sim_fpu_class class;
346: /* General number class and comparison operators.
46:    Needless to say the results, while better than for a packed 64 bit
297: /* Specific number classes.
android.googlesource.com/mirror/superproject:platform/superproject/external/v8/src/mips64/constants-mips64.h:[master, ]
560:   CLASS_S = ((3U << 3) + 3),
586:   CLASS_D = ((3U << 3) + 3),
163: class Registers {
185: class FPURegisters {
334:   COP1 = ((2U << 3) + 1) << kOpcodeShift,  // Coprocessor 1 class.
851: enum class MaxMinKind : int { kMin = 0, kMax = 1 };
902: class InstructionBase {
1021: template <class T>
1022: class InstructionGetters : public T {
1198: class Instruction : public InstructionGetters<InstructionBase> {
1202:   // to allocate or create instances of class Instruction.
1209:   // We need to prevent the creation of instances of class Instruction.
1321: template <class P>
1351: template <class P>
1372: template <class T>
91: // Defines constants and accessor classes to assemble, disassemble and
1221: // TODO(plind): find all usages and remove the needless instructions for n64.
android.googlesource.com/platform/external/qt:Windows-4.7.4/tools/qdoc3/cppcodeparser.cpp:[master, ]
61: #define COMMAND_CLASS                   Doc::alias("class")
88: #define COMMAND_QMLCLASS                Doc::alias("qmlclass")
1608: bool CppCodeParser::matchClassDecl(InnerNode *parent,
194:         // remove needless (and needful) class prefixes
229:     nodeTypeMap.insert(COMMAND_CLASS, Node::Class);
230:     nodeTypeMap.insert(COMMAND_SERVICE, Node::Class);
257:   the same function in the base class.
348:   I think the most important thing it does is resolve class
532:     return QSet<QString>() << COMMAND_CLASS
689:             // class with the actual service name.
704:         if (command == COMMAND_CLASS) {
742:             Node* n = tre->findNode(names[1].split("::"),Node::Class);
971:                     tr("The function either doesn't exist in any base class "
978:               another function in a base class.
1005:                                                       Node::Class));
1606:   Parse a C++ class, union, or struct declarion.
1611:     bool isClass = (tok == Tok_class);
1624:       So far, so good. We have 'class Foo {' or 'class Foo :'.
1625:       This is enough to recognize a class definition.
1936:         case Tok_class:
416:   \a fuzzy is true, base classes are searched. The function
549:                            << COMMAND_QMLCLASS
692:                 ClassNode *cnode = static_cast<ClassNode *>(node);
707:                     ClassNode*cnode = static_cast<ClassNode*>(node);
738:     else if (command == COMMAND_QMLCLASS) {
739:         const ClassNode* classNode = 0;
744:                 classNode = static_cast<const ClassNode*>(n);
747:             return new QmlClassNode(tre->root(), QLatin1String("QML:")+names[0], classNode);
749:             return new QmlClassNode(tre->root(), names[0], classNode);
760:         QmlClassNode* qmlClass = 0;
765:             if (n && n->subType() == Node::QmlClass) {
766:                 qmlClass = static_cast<QmlClassNode*>(n);
768:                     return makeFunctionNode(doc,arg,qmlClass,Node::QmlSignal,false,COMMAND_QMLSIGNAL);
770:                     return makeFunctionNode(doc,arg,qmlClass,Node::QmlSignal,true,COMMAND_QMLATTACHEDSIGNAL);
772:                     return makeFunctionNode(doc,arg,qmlClass,Node::QmlMethod,false,COMMAND_QMLMETHOD);
774:                     return makeFunctionNode(doc,arg,qmlClass,Node::QmlMethod,true,COMMAND_QMLATTACHEDMETHOD);
872:             if (n && n->subType() == Node::QmlClass) {
873:                 QmlClassNode* qmlClass = static_cast<QmlClassNode*>(n);
874:                 if (qmlClass)
875:                     qmlPropGroup = new QmlPropGroupNode(qmlClass,
881:             const ClassNode *correspondingClass = static_cast<const QmlClassNode*>(qmlPropGroup->parent())->classNode();
885:             if (correspondingClass) {
1037:         if (node->subType() == Node::QmlClass) {
1557: bool CppCodeParser::matchBaseSpecifier(ClassNode *classe, bool isClass)
1575:         access = isClass ? Node::Private : Node::Public;
1581:     CodeChunk baseClass;
1582:     if (!matchDataType(&baseClass))
1585:     tre->addBaseClass(classe,
1587:                       baseClass.toPath(),
1588:                       baseClass.toString(),
1589:                       classe->parent());
1593: bool CppCodeParser::matchBaseList(ClassNode *classe, bool isClass)
1596:         if (!matchBaseSpecifier(classe, isClass))
1627:     ClassNode *classe = new ClassNode(parent, previousLexeme());
1628:     classe->setAccess(access);
1629:     classe->setLocation(location());
1631:         classe->setStatus(Node::Compat);
1633:         classe->setModuleName(moduleName);
1634:     classe->setTemplateStuff(templateStuff);
1636:     if (match(Tok_Colon) && !matchBaseList(classe, isClass))
1642:     access = isClass ? Node::Private : Node::Public;
1646:     bool matches = (matchDeclList(classe) && match(Tok_RightBrace) &&
356:     QMapIterator<QString, QString> i(sequentialIteratorClasses);
364:     i = mutableSequentialIteratorClasses;
372:     i = associativeIteratorClasses;
380:     i = mutableAssociativeIteratorClasses;
392:     sequentialIteratorClasses.clear();
393:     mutableSequentialIteratorClasses.clear();
394:     associativeIteratorClasses.clear();
395:     mutableAssociativeIteratorClasses.clear();
427:     int flags = fuzzy ? int(Tree::SearchBaseClasses) : 0;
1038:             QmlClassNode::addInheritedBy(arg,node);
1939:             matchClassDecl(parent, templateStuff);
1994:                 sequentialIteratorClasses.insert(previousLexeme(),
2001:                 mutableSequentialIteratorClasses.insert(previousLexeme(),
2008:                 associativeIteratorClasses.insert(previousLexeme(),
2015:                 mutableAssociativeIteratorClasses.insert(previousLexeme(),
github.com/google/coursebuilder-android-container-module:android/worker.py:[master, ]
110: _ACCEPT_LICENSE_NEEDLE = 'Do you accept the license'
133: _GRADLEW_INSTALL_SUCCESS_NEEDLE = 'BUILD SUCCESSFUL'
145: _TEST_FAILURE_NEEDLE = 'FAILURES!!!\r'
268: class Config(object):
289: class Error(Exception):
290:     """Base error class."""
293: class LockError(Error):
297: class Lock(object):
340: class Patch(object):
347: class TestRun(object):
635: class _Project(object):
638:             self, name, editor_file, package, path, test_class, test_package):
643:         self.test_class = test_class
724:             _Sdk.get_adb(), 'shell', 'am', 'instrument', '-w', '-e', 'class',
725:             self.test_class,
779:         return _GRADLEW_INSTALL_SUCCESS_NEEDLE not in result
782:         return _TEST_FAILURE_NEEDLE in result
785: class _Runtime(object):
1050: class _Sdk(object):
1111:             if _ACCEPT_LICENSE_NEEDLE in line and not process.poll():
1161: class _TestEnvironment(object):
1283:             src_project.package, test_project_path, src_project.test_class,
280:     @classmethod
306:     @classmethod
310:     @classmethod
322:     @classmethod
331:     @classmethod
646:     @classmethod
651:             value['testClass'], value['testPackage'])
797:     @classmethod
1056:     @classmethod
1067:     @classmethod
1071:     @classmethod
1075:     @classmethod
1079:     @classmethod
1091:     @classmethod
1095:     @classmethod
1101:     @classmethod
1105:     @classmethod
1125:     @classmethod
1131:     @classmethod
1135:     @classmethod
1144:     @classmethod
1153:     @classmethod
1188:     @classmethod
1210:     @classmethod
1214:     @classmethod
chromium.googlesource.com/external/googleappengine/python:lib/django-1.5/django/test/testcases.py:[master, ]
462:     client_class = Client
1116:     def setUpClass(cls):
1181:     def tearDownClass(cls):
1167:     def _tearDownClassInternal(cls):
104: class OutputChecker(doctest.OutputChecker):
157: class DocTestRunner(doctest.DocTestRunner):
171: class _AssertNumQueriesContext(object):
200: class _AssertTemplateUsedContext(object):
238: class _AssertTemplateNotUsedContext(_AssertTemplateUsedContext):
246: class SimpleTestCase(ut2.TestCase):
254:         skipped = (getattr(self.__class__, "__unittest_skip__", False) or
308:             expected_exception: Exception class expected to be raised.
323:             fieldclass: the class of the field to be tested.
399:     def assertInHTML(self, needle, haystack, count = None, msg_prefix=''):
400:         needle = assert_and_parse_html(self, needle, None,
404:         real_count = haystack.count(needle)
408:                 " (expected %d)" % (real_count, needle, count))
411:                 msg_prefix + "Couldn't find '%s' in response" % needle)
458: class TransactionTestCase(SimpleTestCase):
460:     # The class we'll use for the test client self.client.
472:             * If the Test Case class has a 'fixtures' member, installing the
474:             * If the Test Case class has a 'urls' member, replace the
478:         self.client = self.client_class()
830: class TestCase(TransactionTestCase):
906: class QuietWSGIRequestHandler(WSGIRequestHandler):
922:     class _ImprovedEvent(threading._Event):
928:         timeout. This class can be removed when Django supports only Python >= 2.7.
941: class StoppableWSGIServer(WSGIServer):
943:     The code in this class is borrowed from the `SocketServer.BaseServer` class
948:     Note for the future: Once Django stops supporting Python 2.6, this class
950:     demand and will not require the use of the _ImprovedEvent class whose code
1015: class _MediaFilesHandler(StaticFilesHandler):
1017:     Handler for serving the media files. This is a private class that is
1032: class LiveServerThread(threading.Thread):
1098: class LiveServerTestCase(TransactionTestCase):
317:     def assertFieldOutput(self, fieldclass, valid, invalid, field_args=None,
337:         required = fieldclass(*field_args, **field_kwargs)
338:         optional = fieldclass(*field_args,
362:         if issubclass(fieldclass, CharField):
364:             self.assertTrue(isinstance(fieldclass(*field_args, **field_kwargs),
365:                                        fieldclass))
461:     # Can be overridden in derived classes.
876:                 issubclass(test_func, TestCase)):
1115:     @classmethod
1159:             # Clean up behind ourselves, since tearDownClass won't get called in
1164:         super(LiveServerTestCase, cls).setUpClass()
1166:     @classmethod
1168:         # There may not be a 'server_thread' attribute if setUpClass() for some
1180:     @classmethod
1183:         super(LiveServerTestCase, cls).tearDownClass()
464:     # Subclasses can ask for resetting of auto increment sequence before each
1161:             cls._tearDownClassInternal()
1182:         cls._tearDownClassInternal()
android.googlesource.com/platform/external/chromium_org:content/public/android/javatests/src/org/chromium/content/browser/ClipboardTest.java:[master, ]
36:     private static final String EXPECTED_HTML_NEEDLE = "http://www.example.com/";
28: public class ClipboardTest extends ContentShellTestBase {
90:             assertTrue(htmlText.contains(EXPECTED_HTML_NEEDLE));
android.googlesource.com/mirror/superproject:platform/external/qt/Mac-4.7.4/tools/qdoc3/cppcodeparser.cpp:[master, ]
61: #define COMMAND_CLASS                   Doc::alias("class")
88: #define COMMAND_QMLCLASS                Doc::alias("qmlclass")
1608: bool CppCodeParser::matchClassDecl(InnerNode *parent,
194:         // remove needless (and needful) class prefixes
229:     nodeTypeMap.insert(COMMAND_CLASS, Node::Class);
230:     nodeTypeMap.insert(COMMAND_SERVICE, Node::Class);
257:   the same function in the base class.
348:   I think the most important thing it does is resolve class
532:     return QSet<QString>() << COMMAND_CLASS
689:             // class with the actual service name.
704:         if (command == COMMAND_CLASS) {
742:             Node* n = tre->findNode(names[1].split("::"),Node::Class);
971:                     tr("The function either doesn't exist in any base class "
978:               another function in a base class.
1005:                                                       Node::Class));
1606:   Parse a C++ class, union, or struct declarion.
1611:     bool isClass = (tok == Tok_class);
1624:       So far, so good. We have 'class Foo {' or 'class Foo :'.
1625:       This is enough to recognize a class definition.
1936:         case Tok_class:
416:   \a fuzzy is true, base classes are searched. The function
549:                            << COMMAND_QMLCLASS
692:                 ClassNode *cnode = static_cast<ClassNode *>(node);
707:                     ClassNode*cnode = static_cast<ClassNode*>(node);
738:     else if (command == COMMAND_QMLCLASS) {
739:         const ClassNode* classNode = 0;
744:                 classNode = static_cast<const ClassNode*>(n);
747:             return new QmlClassNode(tre->root(), QLatin1String("QML:")+names[0], classNode);
749:             return new QmlClassNode(tre->root(), names[0], classNode);
760:         QmlClassNode* qmlClass = 0;
765:             if (n && n->subType() == Node::QmlClass) {
766:                 qmlClass = static_cast<QmlClassNode*>(n);
768:                     return makeFunctionNode(doc,arg,qmlClass,Node::QmlSignal,false,COMMAND_QMLSIGNAL);
770:                     return makeFunctionNode(doc,arg,qmlClass,Node::QmlSignal,true,COMMAND_QMLATTACHEDSIGNAL);
772:                     return makeFunctionNode(doc,arg,qmlClass,Node::QmlMethod,false,COMMAND_QMLMETHOD);
774:                     return makeFunctionNode(doc,arg,qmlClass,Node::QmlMethod,true,COMMAND_QMLATTACHEDMETHOD);
872:             if (n && n->subType() == Node::QmlClass) {
873:                 QmlClassNode* qmlClass = static_cast<QmlClassNode*>(n);
874:                 if (qmlClass)
875:                     qmlPropGroup = new QmlPropGroupNode(qmlClass,
881:             const ClassNode *correspondingClass = static_cast<const QmlClassNode*>(qmlPropGroup->parent())->classNode();
885:             if (correspondingClass) {
1037:         if (node->subType() == Node::QmlClass) {
1557: bool CppCodeParser::matchBaseSpecifier(ClassNode *classe, bool isClass)
1575:         access = isClass ? Node::Private : Node::Public;
1581:     CodeChunk baseClass;
1582:     if (!matchDataType(&baseClass))
1585:     tre->addBaseClass(classe,
1587:                       baseClass.toPath(),
1588:                       baseClass.toString(),
1589:                       classe->parent());
1593: bool CppCodeParser::matchBaseList(ClassNode *classe, bool isClass)
1596:         if (!matchBaseSpecifier(classe, isClass))
1627:     ClassNode *classe = new ClassNode(parent, previousLexeme());
1628:     classe->setAccess(access);
1629:     classe->setLocation(location());
1631:         classe->setStatus(Node::Compat);
1633:         classe->setModuleName(moduleName);
1634:     classe->setTemplateStuff(templateStuff);
1636:     if (match(Tok_Colon) && !matchBaseList(classe, isClass))
1642:     access = isClass ? Node::Private : Node::Public;
1646:     bool matches = (matchDeclList(classe) && match(Tok_RightBrace) &&
356:     QMapIterator<QString, QString> i(sequentialIteratorClasses);
364:     i = mutableSequentialIteratorClasses;
372:     i = associativeIteratorClasses;
380:     i = mutableAssociativeIteratorClasses;
392:     sequentialIteratorClasses.clear();
393:     mutableSequentialIteratorClasses.clear();
394:     associativeIteratorClasses.clear();
395:     mutableAssociativeIteratorClasses.clear();
427:     int flags = fuzzy ? int(Tree::SearchBaseClasses) : 0;
1038:             QmlClassNode::addInheritedBy(arg,node);
1939:             matchClassDecl(parent, templateStuff);
1994:                 sequentialIteratorClasses.insert(previousLexeme(),
2001:                 mutableSequentialIteratorClasses.insert(previousLexeme(),
2008:                 associativeIteratorClasses.insert(previousLexeme(),
2015:                 mutableAssociativeIteratorClasses.insert(previousLexeme(),
github.com/google/contentbox:third_party/django/test/testcases.py:[master, ]
160:     client_class = Client
1141:     def setUpClass(cls):
1206:     def tearDownClass(cls):
1192:     def _tearDownClassInternal(cls):
92: class _AssertNumQueriesContext(CaptureQueriesContext):
110: class _AssertTemplateUsedContext(object):
148: class _AssertTemplateNotUsedContext(_AssertTemplateUsedContext):
156: class SimpleTestCase(ut2.TestCase):
158:     # The class we'll use for the test client self.client.
173:         skipped = (getattr(self.__class__, "__unittest_skip__", False) or
198:         * If the class has a 'urls' attribute, replace ROOT_URLCONF with it.
201:         self.client = self.client_class()
575:             expected_exception: Exception class expected to be raised.
590:             fieldclass: the class of the field to be tested.
666:     def assertInHTML(self, needle, haystack, count=None, msg_prefix=''):
667:         needle = assert_and_parse_html(self, needle, None,
671:         real_count = haystack.count(needle)
675:                 " (expected %d)" % (real_count, needle, count))
678:                 msg_prefix + "Couldn't find '%s' in response" % needle)
725: class TransactionTestCase(SimpleTestCase):
737:         * If the class has an 'available_apps' attribute, restricting the app
740:         * If the class has a 'fixtures' attribute, installing these fixtures.
792:           the class has an 'available_apps' attribute, post_syncdb isn't fired.
851: class TestCase(TransactionTestCase):
932: class QuietWSGIRequestHandler(WSGIRequestHandler):
948:     class _ImprovedEvent(threading._Event):
954:         timeout. This class can be removed when Django supports only Python >= 2.7.
967: class StoppableWSGIServer(WSGIServer):
969:     The code in this class is borrowed from the `SocketServer.BaseServer` class
974:     Note for the future: Once Django stops supporting Python 2.6, this class
976:     demand and will not require the use of the _ImprovedEvent class whose code
1041: class _MediaFilesHandler(StaticFilesHandler):
1043:     Handler for serving the media files. This is a private class that is
1058: class LiveServerThread(threading.Thread):
1123: class LiveServerTestCase(TransactionTestCase):
159:     # Can be overridden in derived classes.
584:     def assertFieldOutput(self, fieldclass, valid, invalid, field_args=None,
604:         required = fieldclass(*field_args, **field_kwargs)
605:         optional = fieldclass(*field_args,
629:         if issubclass(fieldclass, CharField):
631:             self.assertTrue(isinstance(fieldclass(*field_args, **field_kwargs),
632:                                        fieldclass))
902:                 issubclass(test_func, TestCase)):
1140:     @classmethod
1184:             # Clean up behind ourselves, since tearDownClass won't get called in
1189:         super(LiveServerTestCase, cls).setUpClass()
1191:     @classmethod
1193:         # There may not be a 'server_thread' attribute if setUpClass() for some
1205:     @classmethod
1208:         super(LiveServerTestCase, cls).tearDownClass()
727:     # Subclasses can ask for resetting of auto increment sequence before each
731:     # Subclasses can enable only a subset of apps for faster tests
1186:             cls._tearDownClassInternal()
1207:         cls._tearDownClassInternal()
chromium.googlesource.com/external/github.com/v8/node:deps/v8/src/mips64/constants-mips64.h:[master, ]
duplicate result