tests

#!/usr/bin/ruby
OBJC = <<-__EOBJC__

#import <XCTest/XCTest.h>
#import "YOLO.h"



@interface Thingy : NSObject
@property (nonatomic) NSString *title;
@end
@implementation Thingy
@end


int main() {
    unlink("/tmp/YOLOtests.m");  //before or… doesn't happen! FFS
    unlink("/tmp/YOLOtests");

    @autoreleasepool {
      #pragma clang diagnostic push
      #pragma clang diagnostic ignored "-Wdeprecated-declarations"
        XCTSelfTestMain();
      #pragma clang diagnostic pop
    }
}


@interface GeneralTests : XCTestCase
@end


@implementation GeneralTests

- (void)testIndexOfSuccess {
    NSUInteger u = @[@1, @2, @3].indexOf(@2);
    XCTAssertEqual(u, 1ul);
}

- (void)testIndexOfFailure {
    NSUInteger u = @[@1, @2, @3].indexOf(@4);
    XCTAssertEqual(u, NSNotFound);
}

- (void)testPop {
    NSMutableArray *aa = @[@1, @2, @3].mutableCopy;
    [aa pop];
    XCTAssertEqual(aa.count, 2ul);
    id bb = @[@1, @2];
    XCTAssertEqualObjects(aa, bb);
}

- (void)testUniq {
    NSArray *aa = @[@1, @2, @3, @3, @2, @2, @1].uniq;
    XCTAssertEqual(aa.count, 3ul);
    id aaa = @[@1, @2, @3];
    XCTAssertEqualObjects(aaa, aa);
}

- (void)testExtendForm1 {
    NSDictionary *dict = @{@1: @2, @3: @4, @5: @6};
    id other = dict.extend(@{@3: @5});
    XCTAssertEqualObjects(other[@3], @5);
}

- (void)testConcat {
    NSArray *objs = @[@1, @2, @3];
    objs = objs.concat(objs);
    id objs2 = @[@1, @2, @3, @1, @2, @3];
    XCTAssertEqualObjects(objs, objs2);

    NSArray *aa = @[@1, @2, @3].concat(@[@3, @4, @5]);
    id bb = @[@1, @2, @3, @3, @4, @5];
    XCTAssertEqualObjects(aa, bb);

    aa = @[@1, @2, @3, @4, @5];
    aa = aa.skip(2).concat(aa.snip(2));
    bb = @[@3, @4, @5, @1, @2, @3];
    XCTAssertEqualObjects(aa, bb);
}

- (void)testLast {
    id aa = @[@1,@2,@3,@4,@5].last(3);
    id bb = @[@3, @4, @5];
    XCTAssertEqualObjects(aa, bb);
}

- (void)testFirst {
    id aa = @[@1,@2,@3,@4,@5].first(3);
    id bb = @[@1, @2, @3];
    XCTAssertEqualObjects(aa, bb);
}

- (void)testEach {
    __block int x = 0;
    @[@1, @2, @3].each(^(id o){
        XCTAssertEqualObjects(o, @(++x));
    });
    @[@1, @2, @3].each(^(id o, NSUInteger ii){
        XCTAssertEqualObjects(o, @(ii+1));
    });
    @[@1, @2, @3].each(^(id o, int ii){
        XCTAssertEqualObjects(o, @(ii+1));
    });

    @[@0, @1, @2].each(^(id o, id ii){
        XCTAssertEqualObjects(o, ii);
    });
}

- (void)testSelect {
    id aa = @[@1, @2, @3, @4].select(^BOOL(id o) {
        return [o intValue] % 2 == 0;
    });
    id bb = @[@2, @4];
    XCTAssertEqualObjects(aa, bb);
}

- (void)testMin {
    id a = @[@19, @29, @4, @5, @6].min(^(id o) {
        return [o integerValue];
    });
    XCTAssertEqual([a intValue], 4);
    a = @[@19, @29, @4, @5, @6].min(^(id o) {
        return o;
    });
    XCTAssertEqualObjects(a, @4);
}

- (void)testMax {
    id a = @[@19, @29, @4, @5, @6].max(^(id o) {
        return [o integerValue];
    });
    XCTAssertEqual([a intValue], 29);
    a = @[@19, @29, @4, @5, @6].max(^(id o) {
        return o;
    });
    XCTAssertEqualObjects(a, @29);
}

- (void)testFlatten {
    id a = @[@1, @[@1, @2], @[@1, @[@1, @2, @[@1, @[@2, @3]]], @2]];
    XCTAssertEqual([a flatten].count, 10ul);
}

- (void)testFlatMap {
    id aa = @[@1, @2, @3].flatMap(^(id o){
        return @[o, @[o]];
    });
    id bb = @[@1, @[@1], @2, @[@2], @3, @[@3]];
    XCTAssertEqualObjects(aa, bb);
}

- (void)testGroupBy {
    id aa = @[@1, @2, @3, @4].groupBy(^(NSNumber *n) {
        return @(n.intValue % 2);
    });
    id bb = @{@0: @[@2, @4], @1: @[@1, @3]};
    XCTAssertEqualObjects(aa, bb);
}

- (void)testReduce {
    NSNumber *sum = @[@1, @2, @3, @4].reduce(^(NSNumber *memo, NSNumber *num){
        return @(num.intValue + memo.intValue);
    });
    XCTAssertEqual(sum.intValue, 10);
}

- (void)testSlice {
    id aa = @[@1, @2, @3, @4, @5].slice(1, 2);
    id bb = @[@2, @3];
    XCTAssertEqualObjects(aa, bb);
}

- (void)testOverslice {
    NSArray *aa = @[@1, @2, @3, @4];
    id bb = aa.slice(0, 10);
    XCTAssertEqualObjects(aa, bb);
}

- (void)testEmptySlice {
    NSArray *bb = @[].slice(3, 10);
    XCTAssertEqual(bb.count, 0ul);
}

- (void)testEmptyFirst {
    NSArray *bb = @[].first(3);
    XCTAssertEqual(bb.count, 0ul);
}

- (void)testEmptyLast {
    NSArray *bb = @[].last(3);
    XCTAssertEqual(bb.count, 0ul);
}

- (void)testGet {
    XCTAssertEqual([@{@1:@2}.get(@1) intValue], 2);
}

- (void)testPMap {
    NSUInteger const count = 50000;
    NSArray *nums = @(1).upTo(count);
    id aa = nums.pmap(^(NSNumber *num){
        return @(num.intValue * num.intValue);
    });
    id bb = nums.map(^(NSNumber *num){
        return @(num.intValue * num.intValue);
    });
    XCTAssertEqual(count, nums.count);
    XCTAssertEqualObjects(aa, bb);
}

- (void)testUpto {
    id aa = @(4).upTo(6);
    id bb = @[@4, @5, @6];
    XCTAssertEqualObjects(aa, bb);
}

- (void)testPluck {
    Thingy *shape1 = [Thingy new]; shape1.title = @"shape 1";
    Thingy *shape2 = [Thingy new]; shape2.title = @"shape 2";

    id aa = @[shape1, shape2].pluck(@"title.uppercaseString");
    id bb = @[@"SHAPE 1", @"SHAPE 2"];
    XCTAssertEqualObjects(bb, aa);
}

- (void)testSelectClass {
    id bb = @[@1, @"a", @[]].select(NSNumber.class);
    XCTAssertEqualObjects(bb, @[@1]);
}

- (void)testRejectClass {
    id bb = @[@1, @"a", @[]].reject(NSNumber.class);
    id aa =  @[@"a", @[]];
    XCTAssertEqualObjects(bb, aa);
}

- (void)testSortBy {
    id c = @{@3: @"c"};
    id a = @{@1: @"a"};
    id b = @{@2: @"b"};
    id d = @{@2: @"c"};
    id aa = @[c, a, b, d].sortBy(^(NSDictionary *o){
        return o.allKeys.firstObject;
    });
    id bb = @[[a copy], [b copy], [d copy], [c copy]];
    XCTAssertEqualObjects(aa, bb);
}

- (void)testReverse {
    id aa = @[@5, @4, @3, @2, @1];
    id bb = @[@1, @2, @3, @4, @5].reverse;
    XCTAssertEqualObjects(aa, bb);
}

- (void)testJoin {
    NSArray *aa = @[@"a", @1, @"b"];
    id bb = @"a1b";
    XCTAssertEqualObjects(aa.join(@""), bb);
    XCTAssertEqualObjects(aa.join(nil), bb);
}

- (void)testTranspose {
    id aa = @[@[@1, @2], @[@3, @4], @[@5, @6]].transpose;
    id bb = @[@[@1, @3, @5], @[@2, @4, @6]];
    XCTAssertEqualObjects(aa, bb);
}

- (void)testShift {
    NSMutableArray *aa = [NSMutableArray arrayWithObjects:@1, @2, @3, nil];
    XCTAssertEqualObjects(aa.shift, @1);
    XCTAssertEqual(aa.count, 2ul);
}

- (void)testSample {
    id aa = @[@1, @2, @3].sample;
    XCTAssertNotNil(aa);
}

- (void)testPush {
    id aa = [NSMutableArray new].push(@1).push(@2).copy;
    id bb = @[@1, @2];
    XCTAssertEqualObjects(aa, bb);
}

- (void)testString {
    id aa = @"1,2,3,4".split(@",");
    id bb = @[@"1", @"2", @"3", @"4"];
    XCTAssertEqualObjects(aa, bb);

    aa = @"1234".split(@"");
    bb = @[@"1", @"2", @"3", @"4"];
    XCTAssertEqualObjects(aa, bb);
}

- (NSArray *)array:(NSUInteger)count {
    id objs[count];
    for (NSUInteger x = 0; x < count; ++x)
        objs[x] = @(arc4random());
    return [NSArray arrayWithObjects:objs count:count];
}

- (void)testShuffle {
    // obviously there is no good test for shuffle, but we can check that the
    // resulting array has certain characteristics

    NSArray *aa = [self array:50];
    NSArray *bb = aa.shuffle;
    XCTAssertEqual(aa.count, bb.count);
    XCTAssertEqualObjects(aa.sort, bb.sort);
}

- (void)testUnshift {
    NSMutableArray *aa = @[@4, @5, @6].mutableCopy;
    aa.unshift(@3).unshift(@2).unshift(@1);
    id bb = @[@1, @2, @3, @4, @5, @6];
    XCTAssertEqualObjects(bb, aa);
}

- (void)testSnip {
    id aa = @[@1, @2, @3, @4, @5].snip(2);
    id bb = @[@1, @2, @3];
    XCTAssertEqualObjects(bb, aa);
}

- (void)testSkip {
    id aa = @[@1, @2, @3, @4, @5].skip(2);
    id bb = @[@3, @4, @5];
    XCTAssertEqualObjects(bb, aa);
}

- (void)testRotate {
    id aa = @[@1, @2, @3, @4].rotate(2);
    id bb = @[@3, @4, @1, @2];
    XCTAssertEqualObjects(aa, bb);

    id cc = @[@1, @2, @3, @4].rotate(-2);
    id dd = @[@3, @4, @1, @2];
    XCTAssertEqualObjects(aa, bb);
}

- (void)testPushNil {
    NSMutableArray *ma = @[].mutableCopy;
    XCTAssertEqual(0ul, ma.push(nil).count);
}

- (void)testUnshiftNil {
    NSMutableArray *ma = @[@1].mutableCopy;
    XCTAssertEqual(1ul, ma.unshift(nil).count);
}

- (void)testMultiSort {
    id frank12 = @{@"name": @"frank", @"age": @12};
    id zane = @{@"name": @"zane", @"age": @1};
    id bob = @{@"name": @"bob", @"age": @54};
    id frank31 = @{@"name": @"frank", @"age": @31};
    id frank32 = @{@"name": @"frank", @"age": @32};

    NSArray *aa = @[frank32, frank31, bob, zane, frank12];

    id bb = aa.sortBy(^(id o){
        return @[o[@"name"], o[@"age"]];
    });

    id cc = @[
        [bob copy],
        [frank12 copy],
        [frank31 copy],
        [frank32 copy],
        [zane copy]
    ];

    XCTAssertEqualObjects(bb, cc);
}

- (void)testTransposeWithNonEqualCounts {
    id aa = @[@[@1, @2, @3], @[@1, @2]].transpose;
    id bb = @[@[@1, @1], @[@2, @2], @[@3]];
    XCTAssertEqualObjects(aa, bb);
}

- (void)testTransposeNothing {
    id aa = @[].transpose;
    id bb = @[];
    XCTAssertEqualObjects(aa, bb);
}

- (void)testTransposeFlat {
    id aa = @[@1].transpose;
    id bb = @[];
    XCTAssertEqualObjects(aa, bb);
}

- (void)testTransposeOneArray {
    id aa = @[@[@1, @2, @3]].transpose;
    id bb = @[@[@1], @[@2], @[@3]];
    XCTAssertEqualObjects(aa, bb);
}

- (void)testMixedSort {
    NSArray *aa = @[@"20", @4, @"3", @5].sort;
    NSArray *bb = @[@"3", @4, @5, @"20"];
    XCTAssertEqualObjects(aa, bb);
}

- (void)testAll {
    BOOL b = @[@1, @2, @3].all(^BOOL(id o){
        return [o intValue] > 0;
    });
    XCTAssertTrue(b);

    BOOL c = @[@1, @2, @3].all(^BOOL(id o){
        return [o intValue] > 1;
    });
    XCTAssertFalse(c);
}

- (void)testAllClass {
    BOOL d = @[@1, @2, @3].all(NSNumber.class);
    XCTAssertTrue(d);

    d = @[@"1", @"2", @"3"].all(NSString.class);
    XCTAssertTrue(d);

    d = @[@"1", @2, @"3"].all(NSString.class);
    XCTAssertFalse(d);
}

- (void)testStringSort {
    id aa = @[@"103", @"11", @"10", @"12"].sort;
    id bb = @[@"10", @"11", @"12", @"103"];
    XCTAssertEqualObjects(aa, bb);
}

- (void)testNone {
    BOOL b = @[@"1", @"2", @"3"].none(NSNumber.class);
    XCTAssertTrue(b);

    b = @[@1, @"2", @"3"].none(NSNumber.class);
    XCTAssertFalse(b);

    b = @[@"1", @"2", @"3"].none(NSString.class);
    XCTAssertFalse(b);
}

- (void)testPluckNil {
    NSArray *aa = @[@1];
    XCTAssertEqualObjects(aa.pluck(nil), aa);
}

- (void)testPluckEmpty {
    NSArray *aa = @[@1];
    XCTAssertEqualObjects(aa.pluck(@""), aa);
}

- (void)testUpToFromNegative {
    NSArray *aa = @(-5).upTo(20);
    XCTAssertEqual([aa[0] intValue], -5);
    XCTAssertEqual([aa[25] intValue], 20);
}

- (void)testInject {
    id aa = @[@1, @2, @3].inject(@{}, ^(id memo, NSNumber *value){
        memo[value] = @(value.intValue * 2);
        return memo;
    });
    id bb = @{@1: @2, @2: @4, @3: @6};
    XCTAssertEqualObjects(aa, bb);
    XCTAssertFalse([aa classForCoder] == [NSMutableDictionary class]);

    id whatWePutIn = [NSMutableDictionary new];
    aa = @[@1, @2, @3].inject(whatWePutIn, ^(id memo, NSNumber *value){
        memo[value] = @(value.intValue * 2);
        return memo;
    });
    bb = @{@1: @2, @2: @4, @3: @6};
    XCTAssertEqualObjects(aa, bb);
    XCTAssertTrue([aa classForCoder] == [NSMutableDictionary class]);
    XCTAssertTrue(whatWePutIn == aa);
}

- (void)testExtendNil {
    NSDictionary *aa = @{@1: @2};
    id bb = aa.extend(nil);
    XCTAssertEqualObjects(aa, bb);
}

- (void)testAny {
    NSArray *aa = @[@1, @2, @3, @4];
    XCTAssertTrue(aa.any(^BOOL(id o){ return [o intValue] == 4; }));
    XCTAssertFalse(aa.any(^BOOL(id o){ return [o intValue] == 5; }));
}

- (void)testHas {
    NSArray *aa = @[@1,@2,@3];
    XCTAssertTrue(aa.has(@3));
}

- (void)testSelectNil {
    id aa = @[@1, @2].select(nil);
    id bb = @[];
    XCTAssertEqualObjects(aa, bb);
}

- (void)testDictionaryArray {
    NSDictionary *d = @{@3: @"c", @1: @"a", @4: @"d", @2: @"b"};
    id a = d.array.sort.transpose[1];
    id b = @[@"a", @"b", @"c", @"d"];
    XCTAssertEqualObjects(a, b);
}

- (void)testDictionaryMap {
    id aa = @{@1: @2, @2: @4, @3: @9}.map(^(id key, id obj){
        return @([key intValue] + [obj intValue]);
    }).sort;
    id bb = @[@3, @6, @12];
    XCTAssertEqualObjects(aa, bb);
}

- (void)testArrayToDict {
    id aa = @[@[@1, @2], @[@3, @4], @[@5, @6]];
    id dd = [aa dict];
    id ee = @{@1: @2, @3: @4, @5: @6};
    XCTAssertEqualObjects(dd, ee);

    aa = @[@1, @2, @3, @4, @5, @6].chunk(2);
    dd = [aa dict];
    XCTAssertEqualObjects(dd, ee);
}

- (void)testChunk {
    id aa = @[@1, @2, @3, @4].chunk(2);
    id bb = @[@[@1, @2], @[@3, @4]];
    XCTAssertEqualObjects(aa, bb);
}

- (void)testPartition {
    id aa = @[@1, @2, @3, @4].partition(^(NSNumber *n){
        return n.intValue % 2 == 0;
    });
    id bb = @[@[@2, @4], @[@1, @3]];
    XCTAssertEqualObjects(aa, bb);
    
    aa = @[@"A", @"B", @"AA"].partition(^(NSString *s){
        return [s hasPrefix:@"A"];
    });
    bb = @[@[@"A", @"AA"], @[@"B"]];
    XCTAssertEqualObjects(aa, bb);
}

- (void)testMap {
    NSArray *aaa = @[@"a", @"b", @"c", @"d"];
    NSArray *aa = aaa.map(^(id o, uint ii, id array){
        return @[o, @(ii), array];
    });
    id bb = @[@[@"a", @0, aaa], @[@"b", @1, aaa], @[@"c", @2, aaa], @[@"d", @3, aaa]];
    XCTAssertEqualObjects(aa, bb);

    aa = @[@"a", @"b", @"c", @"d"];
    bb = aa.map(^(id o){
        return o;
    });
    XCTAssertEqualObjects(aa, bb);

    bb = aa.map(^(id o, id i){
        return [NSString stringWithFormat:@"%@%@", o, i];
    });
    aa = @[@"a0", @"b1", @"c2", @"d3"];
    XCTAssertEqualObjects(aa, bb);
}

- (void)testUniqedArrayMap {
    NSArray *aaa = @[@"a", @"b", @"a"];
    NSArray *aa = @[@"a", @"b"];
    id bb = aaa.uniq.map(^(id o) { return o; });
    XCTAssertEqualObjects(aa, bb);
}

- (void)testArrayFmap {
    NSArray *aaa = @[@"a", @"b", @"c", @"d"];
    NSArray *aa = aaa.fmap(^(id o, uint ii, id array){
        return @[o, @(ii), array];
    });
    id bb = @[@[@"a", @0, aaa], @[@"b", @1, aaa], @[@"c", @2, aaa], @[@"d", @3, aaa]];
    XCTAssertEqualObjects(aa, bb);
    XCTAssertFalse([aa isKindOfClass:[NSMutableArray class]]);

    aa = @[@"a", @"b", @"c", @"d"];
    bb = aa.fmap(^(id o){
        return o;
    });
    XCTAssertEqualObjects(aa, bb);
    
    bb = aa.fmap(^(id o, id i){
        return [NSString stringWithFormat:@"%@%@", o, i];
    });
    aa = @[@"a0", @"b1", @"c2", @"d3"];
    XCTAssertEqualObjects(aa, bb);

    bb = ((NSArray *)aa.mutableCopy).fmap(^(id o) { return o; });
    XCTAssertEqualObjects(aa, bb);
}

- (void)testSetFmap {
    NSSet *aa = [NSSet setWithObjects:@1, @2, @3, nil];

    XCTAssertEqualObjects((aa.fmap(^(id obj) { return obj; })), aa);
    XCTAssertEqualObjects((aa.fmap(^(id obj) { return (id)nil; })), [NSSet set]);
    
    id bb = aa.fmap(^(id obj) {
        return @([obj intValue] * [obj intValue]);
    });
    XCTAssertEqualObjects(bb, ([NSSet setWithObjects:@1, @4, @9, nil]));
    XCTAssertFalse([bb isKindOfClass:[NSMutableSet class]]);
    
    bb = ((NSSet *)aa.mutableCopy).fmap(^(id obj) {
        return @([obj intValue] * [obj intValue]);
    });
    XCTAssertEqualObjects(bb, ([NSSet setWithObjects:@1, @4, @9, nil]));
}

- (void)testDictionaryFmap {
    XCTAssertEqualObjects(@{}, (@{}.fmap(^(id obj) { return obj; })));

    NSDictionary *aa = @{@1: @2, @2: @4, @3: @9};
    XCTAssertEqualObjects(aa, (aa.fmap(^(id obj) { return obj; })));

    id bb = aa.fmap(^(id obj){
        return @([obj intValue] * 2);
    });
    XCTAssertEqualObjects(bb, (@{@1: @4, @2: @8, @3: @18}));
    XCTAssertFalse([bb isKindOfClass:[NSMutableDictionary class]]);

    bb = aa.fmap(^(id obj, id key){
        return @([obj intValue] * 2 + [key intValue]);
    });
    XCTAssertEqualObjects(bb, (@{@1: @5, @2: @10, @3: @21}));

    bb = ((NSDictionary *)aa.mutableCopy).fmap(^(id obj){
        return @([obj intValue] * 2);
    });
    XCTAssertEqualObjects(bb, (@{@1: @4, @2: @8, @3: @18}));
}

- (void)testPick {
    NSDictionary *a = @{@1: @2, @2: @3, @3: @4};
    id b = a.pick(@1, @2, @5, nil);
    id c = @{@1: @2, @2: @3};
    XCTAssertEqualObjects(b, c);
}

- (void)testSortByInteger {
    id a = @[@2, @1, @3, @4].sortBy(^(id o){
        return [o intValue];
    });
    id b = @[@1, @2, @3, @4];
    XCTAssertEqualObjects(a, b);
}

- (void)testAllBoxes {
    __block int x = 1;
    @[@1, @2, @3].all(^(int d){
        XCTAssertEqual(x++, d);
    });
}

- (void)testEmptySample {
  XCTAssertNil(@[].sample);
}

@end



__EOBJC__

FRAMEWORKS = begin
  attempt1 = "/Applications/Xcode.app/Contents/Developer/Library/Frameworks"
  if File.directory? "#{attempt1}/XCTest.framework"
    attempt1
  else
    "/Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/Library/Frameworks"
  end
end

File.open('/tmp/YOLOtests.m', 'w') do |f|
  f.puts("\n\n")  # make line numbers line up
  f.puts(OBJC)
end

abort unless system <<-EOS
  clang -g -O0 -ObjC -F#{FRAMEWORKS} -includeYOLO-all.h -I. -fmodules -fobjc-arc \
        -framework XCTest \
        -Wno-incomplete-implementation \
        /tmp/YOLOtests.m *.m -o /tmp/YOLOtests
EOS
abort unless system <<-EOS
    install_name_tool -change \
        @rpath/XCTest.framework/Versions/A/XCTest \
        #{FRAMEWORKS}/XCTest.framework/XCTest \
        /tmp/YOLOtests
EOS

require "stringio"
require "open3"

def bold(s); s;end
def red(s); "\e[31m#{s}\e[0m";end
def green(s); "\e[32m#{s}\e[0m";end
def tab(n, s); s.gsub(/^/, " " * n); end
def log(message); $stdout.write message + "\n";end


Open3.popen3("/tmp/YOLOtests") do |stdin, stdout, stderr, wait_thr|
  while line = stderr.gets
    case line
    when /Test Suite '(.*)' started/
      log bold($1)
    when /Test Suite '.*' finished/
    when /\[(\w+) (\w+)\]' started.$/
      test_method = $2
    when /\s(passed|failed)\s\((.*)\)/
      result = if $1 == "passed"
        green("PASS") 
      else
        red("FAIL")
      end
      result = tab(2, result)
      time = $2.gsub(/\sseconds/, "s")
      log "#{result} #{test_method} (#{time})"
    when /^(Executed(.?)+)$/
      if stderr.eof?
        summary = $1
        if /(\d) failures?/.match(summary)[1] == "0"
          summary.gsub!(/(\d failures?)/, green('\1'))
        else
          summary.gsub!(/(\d failures?)/, red('\1'))
        end
        log summary
      end
    else
      log line.strip
    end
  end
end