Genese complexity report

<- assert.d.ts
Methods : 28
Complexity index : 26.8
Cyclomatic complexity : 27
Cognitive complexity
100 % Correct 28/28
0 % Warning 0/28 (threshold : 10)
0 % Error 0/28 (threshold : 20)
Cyclomatic complexity
100 % Correct 28/28
0 % Warning 0/28 (threshold : 5)
0 % Error 0/28 (threshold : 10)
Methods of assert.d.ts
assert Complexity Index 0.8 Cyclomatic complexity 1
                            
                                
            
                /** An alias of `assert.ok()`. */
                function assert(value: any, message?: string | Error): asserts value; // ------- +0.8 Complexity index (+0.8 atomic)
            
                            
                        
Complexity Index 1.1 Cyclomatic complexity 0
                            
                                
                        
            
                        constructor(options?: { // -------------------------------------------------------------------- +0.1 Complexity index (+0.1 atomic)
                            /** If provided, the error message is set to this value. */
                            message?: string; // ---------------------------------------------------------------------- +0.2 Complexity index (+0.2 atomic)
                            /** The `actual` property on the error instance. */
                            actual?: any; // -------------------------------------------------------------------------- +0.2 Complexity index (+0.2 atomic)
                            /** The `expected` property on the error instance. */
                            expected?: any; // ------------------------------------------------------------------------ +0.2 Complexity index (+0.2 atomic)
                            /** The `operator` property on the error instance. */
                            operator?: string; // --------------------------------------------------------------------- +0.2 Complexity index (+0.2 atomic)
                            /** If provided, the generated stack trace omits frames before this function. */
                            stackStartFn?: Function; // --------------------------------------------------------------- +0.2 Complexity index (+0.2 atomic)
                        });
            
                            
                        
calls Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                    
                        calls(exact?: number): () => void; // ------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
calls Complexity Index 1 Cyclomatic complexity 1
                            
                                
                        
                        calls<Func extends (...args: any[]) => any>(fn?: Func, exact?: number): Func; // ------- +1.0 Complexity index (+1.0 atomic)
            
                            
                        
report Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                        
                        report(): CallTrackerReportInformation[]; // ------------------------------------------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
verify Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                        
                        verify(): void; // --------------------------------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
fail Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                    
            
                    function fail(message?: string | Error): never; // --------------------------------------------------------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
fail Complexity Index 1.3 Cyclomatic complexity 1
                            
                                
                    
                    /** @deprecated since v10.0.0 - use fail([message]) or other assert functions instead. */
                    function fail( // ---------------------------------------------------------------------------------- +0.1 Complexity index (+0.1 atomic)
                        actual: any, // -------------------------------------------------------------------------------- +0.2 Complexity index (+0.2 atomic)
                        expected: any, // ------------------------------------------------------------------------------ +0.2 Complexity index (+0.2 atomic)
                        message?: string | Error, // ------------------------------------------------------------------- +0.4 Complexity index (+0.4 atomic)
                        operator?: string, // -------------------------------------------------------------------------- +0.2 Complexity index (+0.2 atomic)
                        stackStartFn?: Function, // -------------------------------------------------------------------- +0.2 Complexity index (+0.2 atomic)
                    ): never;
            
                            
                        
ok Complexity Index 0.8 Cyclomatic complexity 1
                            
                                
                    
                    function ok(value: any, message?: string | Error): asserts value; // ------- +0.8 Complexity index (+0.8 atomic)
            
                            
                        
equal Complexity Index 1 Cyclomatic complexity 1
                            
                                
                    
                    /** @deprecated since v9.9.0 - use strictEqual() instead. */
                    function equal(actual: any, expected: any, message?: string | Error): void; // ------- +1.0 Complexity index (+1.0 atomic)
            
                            
                        
notEqual Complexity Index 1 Cyclomatic complexity 1
                            
                                
                    
                    /** @deprecated since v9.9.0 - use notStrictEqual() instead. */
                    function notEqual(actual: any, expected: any, message?: string | Error): void; // ------- +1.0 Complexity index (+1.0 atomic)
            
                            
                        
deepEqual Complexity Index 1 Cyclomatic complexity 1
                            
                                
                    
                    /** @deprecated since v9.9.0 - use deepStrictEqual() instead. */
                    function deepEqual(actual: any, expected: any, message?: string | Error): void; // ------- +1.0 Complexity index (+1.0 atomic)
            
                            
                        
notDeepEqual Complexity Index 1 Cyclomatic complexity 1
                            
                                
                    
                    /** @deprecated since v9.9.0 - use notDeepStrictEqual() instead. */
                    function notDeepEqual(actual: any, expected: any, message?: string | Error): void; // ------- +1.0 Complexity index (+1.0 atomic)
            
                            
                        
strictEqual Complexity Index 1.2 Cyclomatic complexity 1
                            
                                
                    
                    function strictEqual<T>(actual: any, expected: T, message?: string | Error): asserts actual is T; // ------- +1.2 Complexity index (+1.2 atomic)
            
                            
                        
notStrictEqual Complexity Index 1 Cyclomatic complexity 1
                            
                                
                    
                    function notStrictEqual(actual: any, expected: any, message?: string | Error): void; // -------------------- +1.0 Complexity index (+1.0 atomic)
            
                            
                        
deepStrictEqual Complexity Index 1.2 Cyclomatic complexity 1
                            
                                
                    
                    function deepStrictEqual<T>(actual: any, expected: T, message?: string | Error): asserts actual is T; // ------- +1.2 Complexity index (+1.2 atomic)
            
                            
                        
notDeepStrictEqual Complexity Index 1 Cyclomatic complexity 1
                            
                                
                    
                    function notDeepStrictEqual(actual: any, expected: any, message?: string | Error): void; // -------------------- +1.0 Complexity index (+1.0 atomic)
            
                            
                        
throws Complexity Index 0.8 Cyclomatic complexity 1
                            
                                
                    
            
                    function throws(block: () => any, message?: string | Error): void; // ----------------------------- +0.8 Complexity index (+0.8 atomic)
            
                            
                        
throws Complexity Index 1 Cyclomatic complexity 1
                            
                                
                    
                    function throws(block: () => any, error: AssertPredicate, message?: string | Error): void; // ------- +1.0 Complexity index (+1.0 atomic)
            
                            
                        
doesNotThrow Complexity Index 0.8 Cyclomatic complexity 1
                            
                                
                    
                    function doesNotThrow(block: () => any, message?: string | Error): void; // ------------------------- +0.8 Complexity index (+0.8 atomic)
            
                            
                        
doesNotThrow Complexity Index 1.2 Cyclomatic complexity 1
                            
                                
                    
                    function doesNotThrow(block: () => any, error: RegExp | Function, message?: string | Error): void; // ------- +1.2 Complexity index (+1.2 atomic)
            
                            
                        
ifError Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                    
            
                    function ifError(value: any): asserts value is null | undefined; // ----------------------------------------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
rejects Complexity Index 1.3 Cyclomatic complexity 1
                            
                                
                    
            
                    function rejects(block: (() => Promise<any>) | Promise<any>, message?: string | Error): Promise<void>; // ------- +1.3 Complexity index (+1.3 atomic)
            
                            
                        
rejects Complexity Index 1.5 Cyclomatic complexity 1
                            
                                
                    
                    function rejects( // -------------------------------------------------------------------------------------------- +0.1 Complexity index (+0.1 atomic)
                        block: (() => Promise<any>) | Promise<any>, // -------------------------------------------------------------- +0.6 Complexity index (+0.6 atomic)
                        error: AssertPredicate, // ---------------------------------------------------------------------------------- +0.2 Complexity index (+0.2 atomic)
                        message?: string | Error, // -------------------------------------------------------------------------------- +0.4 Complexity index (+0.4 atomic)
                    ): Promise<void>; // -------------------------------------------------------------------------------------------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
doesNotReject Complexity Index 1.3 Cyclomatic complexity 1
                            
                                
                    
                    function doesNotReject(block: (() => Promise<any>) | Promise<any>, message?: string | Error): Promise<void>; // ------- +1.3 Complexity index (+1.3 atomic)
            
                            
                        
doesNotReject Complexity Index 1.7 Cyclomatic complexity 1
                            
                                
                    
                    function doesNotReject( // -------------------------------------------------------------------------------------------- +0.1 Complexity index (+0.1 atomic)
                        block: (() => Promise<any>) | Promise<any>, // -------------------------------------------------------------------- +0.6 Complexity index (+0.6 atomic)
                        error: RegExp | Function, // -------------------------------------------------------------------------------------- +0.4 Complexity index (+0.4 atomic)
                        message?: string | Error, // -------------------------------------------------------------------------------------- +0.4 Complexity index (+0.4 atomic)
                    ): Promise<void>; // -------------------------------------------------------------------------------------------------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
match Complexity Index 1 Cyclomatic complexity 1
                            
                                
                    
            
                    function match(value: string, regExp: RegExp, message?: string | Error): void; // ------- +1.0 Complexity index (+1.0 atomic)
            
                            
                        
doesNotMatch Complexity Index 1 Cyclomatic complexity 1
                            
                                
                    
                    function doesNotMatch(value: string, regExp: RegExp, message?: string | Error): void; // ------- +1.0 Complexity index (+1.0 atomic)