View GitHub Repository timeago

Schedule Inspection
Subscribe
Passed
Push — master ( 2df23a...0c8182 )
by Serhii
01:29
created

timeago.TestTake   B

↳ Parent: timeago_test.go

Complexity

Conditions 4

Size

Total Lines 122
Code Lines 116

Duplication

Lines 0
Ratio 0 %

Importance

Changes 0
Metric Value
cc 4
eloc 116
nop 1
dl 0
loc 122
rs 7
c 0
b 0
f 0

How to fix   Long Method   

Long Method

Small methods make your code easier to understand, in particular if combined with a good name. Besides, if your method is small, finding a good name is usually much easier.

For example, if you find yourself adding comments to a method's body, this is usually a good sign to extract the commented part to a new method, and use the comment as a starting point when coming up with a good name for this new method.

Commonly applied refactorings include:

1 
package timeago
2 

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    3
                

                                    
                                                    
                
                
                
import (

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    4
                

                                    
                                                    
                
                
                
	"testing"

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    5
                

                                    
                                                    
                
                
                
	"time"

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    6
                

                                    
                                                    
                
                
                
)

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    7
                

                                    
                                                    
                
                
                

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    8
                

                                    
                                                    
                
                
                
// test helper

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    9
                

                                    
                                                    
                
                
                
func smallSubTime(d time.Duration) string {

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    10
                

                                    
                                                    
                
                
                
	return time.Now().Add(d).Format("2006-01-02 15:04:05")

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    11
                

                                    
                                                    
                
                
                
}

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    12
                

                                    
                                                    
                
                
                

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    13
                

                                    
                                                    
                
                
                
// test helper

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    14
                

                                    
                                                    
                
                
                
func bigSubTime(years int, months int, days int) string {

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    15
                

                                    
                                                    
                
                
                
	return time.Now().AddDate(-years, -months, -days).Format("2006-01-02 15:04:05")

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    16
                

                                    
                                                    
                
                
                
}

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    17
                

                                    
                                                    
                
                
                

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    18
                

                                    
                                                    
                
                
                
func TestGetOption(test *testing.T) {

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    19
                

                                    
                                                    
                
                
                
	cases := []struct {

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    20
                

                                    
                                                    
                
                
                
		name            string

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    21
                

                                    
                                                    
                
                
                
		date            string

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    22
                

                                    
                                                    
                
                
                
		optionMustBe    string

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    23
                

                                    
                                                    
                
                
                
		hasOptionMustBe bool

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    24
                

                                    
                                                    
                
                
                
	}{

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    25
                

                                    
                                                    
                
                
                
		{"case has online option", "2017-02-01 00:00:00|online", "online", true},

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    26
                

                                    
                                                    
                
                
                
		{"case has random option", "2017-02-01 00:00:00|random", "random", true},

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    27
                

                                    
                                                    
                
                
                
		{"case has online option", "2017-02-01 00:00:00|korotchaeva", "korotchaeva", true},

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    28
                

                                    
                                                    
                
                
                
		{"case don't have option", "2017-02-01 00:00:00", "", false},

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    29
                

                                    
                                                    
                
                
                
	}

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    30
                

                                    
                                                    
                
                
                

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    31
                

                                    
                                                    
                
                
                
	for _, tc := range cases {

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    32
                

                                    
                                                    
                
                
                
		test.Run(tc.name, func(t *testing.T) {

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    33
                

                                    
                                                    
                
                
                
			option, hasOption := getOption(&tc.date)

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    34
                

                                    
                                                    
                
                
                

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    35
                

                                    
                                                    
                
                
                
			if hasOption != tc.hasOptionMustBe || option != tc.optionMustBe {

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    36
                

                                    
                                                    
                
                
                
				t.Errorf("Result of getOption func must return `online` string and `true`, but `%s` string and `%v` returned returned", tc.optionMustBe, tc.hasOptionMustBe)

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    37
                

                                    
                                                    
                
                
                
			}

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    38
                

                                    
                                                    
                
                
                
		})

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    39
                

                                    
                                                    
                
                
                
	}

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    40
                

                                    
                                                    
                
                
                
}

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    41
                

                                    
                                                    
                
                
                

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    42
                

                                    
                                                    
                
                
                
func TestGetTimeTranslations(t *testing.T) {

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    43
                

                                    
                                                    
                
                
                
	t.Parallel()

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    44
                

                                    
                                                    
                
                
                

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    45
                

                                    
                                                    
                
                
                
	t.Run("returns 7 items", func(test *testing.T) {

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    46
                

                                    
                                                    
                
                
                
		if res := len(getTimeTranslations()); res != 7 {

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    47
                

                                    
                                                    
                
                
                
			test.Errorf("Must return 7 items but got %d", res)

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    48
                

                                    
                                                    
                
                
                
		}

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    49
                

                                    
                                                    
                
                
                
	})

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    50
                

                                    
                                                    
                
                
                

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    51
                

                                    
                                                    
                
                
                
	t.Run("every slice has 3 items", func(test *testing.T) {

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    52
                

                                    
                                                    
                
                
                
		for _, slice := range getTimeTranslations() {

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    53
                

                                    
                                                    
                
                
                
			if res := len(slice); res != 3 {

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    54
                

                                    
                                                    
                
                
                
				test.Errorf("Slice Must return 3 items but got %d", res)

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    55
                

                                    
                                                    
                
                
                
			}

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    56
                

                                    
                                                    
                
                
                
		}

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    57
                

                                    
                                                    
                
                
                
	})

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    58
                

                                    
                                                    
                
                
                
}

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    59
                

                                    
                                                    
                
                
                

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    60
                

                                    
                                                    
                
                
                
func TestGetWords(t *testing.T) {

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    61
                

                                    
                                                    
                
                
                
	cases := []struct {

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    62
                

                                    
                                                    
                
                
                
		timeKind string

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    63
                

                                    
                                                    
                
                
                
		num      int

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    64
                

                                    
                                                    
                
                
                
		result   string

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    65
                

                                    
                                                    
                
                
                
		lang     string

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    66
                

                                    
                                                    
                
                
                
	}{

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    67
                

                                    
                                                    
                
                
                
		// english

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    68
                

                                    
                                                    
                
                
                
		{"seconds", 1, "1 second ago", "en"},

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    69
                

                                    
                                                    
                
                
                
		{"seconds", 2, "2 seconds ago", "en"},

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    70
                

                                    
                                                    
                
                
                
		{"days", 11, "11 days ago", "en"},

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    71
                

                                    
                                                    
                
                
                
		{"days", 21, "21 day ago", "en"},

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    72
                

                                    
                                                    
                
                
                
		{"seconds", 30, "30 seconds ago", "en"},

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    73
                

                                    
                                                    
                
                
                
		{"seconds", 31, "31 second ago", "en"},

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    74
                

                                    
                                                    
                
                
                
		{"hours", 10, "10 hours ago", "en"},

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    75
                

                                    
                                                    
                
                
                
		{"years", 2, "2 years ago", "en"},

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    76
                

                                    
                                                    
                
                
                
		// russian

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    77
                

                                    
                                                    
                
                
                
		{"seconds", 1, "1 секунда назад", "ru"},

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    78
                

                                    
                                                    
                
                
                
		{"minutes", 2, "2 минуты назад", "ru"},

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    79
                

                                    
                                                    
                
                
                
		{"seconds", 3, "3 секунды назад", "ru"},

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    80
                

                                    
                                                    
                
                
                
		{"seconds", 4, "4 секунды назад", "ru"},

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    81
                

                                    
                                                    
                
                
                
		{"hours", 5, "5 часов назад", "ru"},

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    82
                

                                    
                                                    
                
                
                
		{"days", 11, "11 дней назад", "ru"},

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    83
                

                                    
                                                    
                
                
                
		{"years", 21, "21 год назад", "ru"},

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    84
                

                                    
                                                    
                
                
                
		{"minutes", 59, "59 минут назад", "ru"},

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    85
                

                                    
                                                    
                
                
                
	}

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    86
                

                                    
                                                    
                
                
                

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    87
                

                                    
                                                    
                
                
                
	for _, tc := range cases {

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    88
                

                                    
                                                    
                
                
                
		t.Run(tc.result, func(test *testing.T) {

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    89
                

                                    
                                                    
                
                
                
			Set("language", tc.lang)

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    90
                

                                    
                                                    
                
                
                
			Set("location", "Europe/Kiev")

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    91
                

                                    
                                                    
                
                
                

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    92
                

                                    
                                                    
                
                
                
			if res := getWords(tc.timeKind, tc.num); res != tc.result {

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    93
                

                                    
                                                    
                
                
                
				test.Errorf("Result must be `%s` but got `%s` instead", tc.result, res)

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    94
                

                                    
                                                    
                
                
                
			}

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    95
                

                                    
                                                    
                
                
                
		})

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    96
                

                                    
                                                    
                
                
                
	}

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    97
                

                                    
                                                    
                
                
                
}

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    98
                

                                    
                                                    
                
                
                

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    99
                

                                    
                                                    
                
                
                
func TestGetLastNumber(t *testing.T) {

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    100
                

                                    
                                                    
                
                
                
	cases := []struct {

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    101
                

                                    
                                                    
                
                
                
		number int

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    102
                

                                    
                                                    
                
                
                
		result int

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    103
                

                                    
                                                    
                
                
                
		name   string

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    104
                

                                    
                                                    
                
                
                
	}{

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    105
                

                                    
                                                    
                
                
                
		{0, 0, "must return 0"},

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    106
                

                                    
                                                    
                
                
                
		{1, 1, "must return 1"},

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    107
                

                                    
                                                    
                
                
                
		{9, 9, "must return 9"},

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    108
                

                                    
                                                    
                
                
                
		{20, 0, "must return 0"},

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    109
                

                                    
                                                    
                
                
                
		{253, 3, "must return 3"},

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    110
                

                                    
                                                    
                
                
                
		{23423252, 2, "must return 2"},

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    111
                

                                    
                                                    
                
                
                
		{223424342325, 5, "must return 5"},

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    112
                

                                    
                                                    
                
                
                
		{23423521562348, 8, "must return 8"},

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    113
                

                                    
                                                    
                
                
                
	}

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    114
                

                                    
                                                    
                
                
                

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    115
                

                                    
                                                    
                
                
                
	for _, tc := range cases {

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    116
                

                                    
                                                    
                
                
                
		t.Run(tc.name, func(test *testing.T) {

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    117
                

                                    
                                                    
                
                
                
			if res := getLastNumber(tc.number); res != tc.result {

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    118
                

                                    
                                                    
                
                
                
				test.Errorf("Result must be %d, but got %d instead", tc.result, res)

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    119
                

                                    
                                                    
                
                
                
			}

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    120
                

                                    
                                                    
                
                
                
		})

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    121
                

                                    
                                                    
                
                
                
	}

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    122
                

                                    
                                                    
                
                
                
}

            


            
                                                                                                            
                                                                
            
                                    
            
            

                
                    123
                

                                    
                                                    
                
                
                

            


            
                                                                        
                            
            
                                    
            
            

                
                    124
                

                                    
                                                    
                
                
                
func TestTake(t *testing.T) {

            


            
                                                                        
                            
            
                                    
            
            

                
                    125
                

                                    
                                                    
                
                
                
	cases := []struct {

            


            
                                                                        
                            
            
                                    
            
            

                
                    126
                

                                    
                                                    
                
                
                
		date   string

            


            
                                                                        
                            
            
                                    
            
            

                
                    127
                

                                    
                                                    
                
                
                
		result string

            


            
                                                                        
                            
            
                                    
            
            

                
                    128
                

                                    
                                                    
                
                
                
		lang   string

            


            
                                                                        
                            
            
                                    
            
            

                
                    129
                

                                    
                                                    
                
                
                
	}{

            


            
                                                                        
                            
            
                                    
            
            

                
                    130
                

                                    
                                                    
                
                
                
		// english

            


            
                                                                        
                            
            
                                    
            
            

                
                    131
                

                                    
                                                    
                
                
                
		{smallSubTime(time.Second * 2), "0 seconds ago", "en"},

            


            
                                                                        
                            
            
                                    
            
            

                
                    132
                

                                    
                                                    
                
                
                
		{smallSubTime(time.Second), "0 seconds ago", "en"},

            


            
                                                                        
                            
            
                                    
            
            

                
                    133
                

                                    
                                                    
                
                
                
		{smallSubTime(-1 * time.Second), "1 second ago", "en"},

            


            
                                                                        
                            
            
                                    
            
            

                
                    134
                

                                    
                                                    
                
                
                
		{smallSubTime(-2 * time.Second), "2 seconds ago", "en"},

            


            
                                                                        
                            
            
                                    
            
            

                
                    135
                

                                    
                                                    
                
                
                
		{smallSubTime(-9 * time.Second), "9 seconds ago", "en"},

            


            
                                                                        
                            
            
                                    
            
            

                
                    136
                

                                    
                                                    
                
                
                
		{smallSubTime(-10 * time.Second), "10 seconds ago", "en"},

            


            
                                                                        
                            
            
                                    
            
            

                
                    137
                

                                    
                                                    
                
                
                
		{smallSubTime(-11 * time.Second), "11 seconds ago", "en"},

            


            
                                                                        
                            
            
                                    
            
            

                
                    138
                

                                    
                                                    
                
                
                
		{smallSubTime(-20 * time.Second), "20 seconds ago", "en"},

            


            
                                                                        
                            
            
                                    
            
            

                
                    139
                

                                    
                                                    
                
                
                
		{smallSubTime(-21 * time.Second), "21 second ago", "en"},

            


            
                                                                        
                            
            
                                    
            
            

                
                    140
                

                                    
                                                    
                
                
                
		{smallSubTime(-22 * time.Second), "22 seconds ago", "en"},

            


            
                                                                        
                            
            
                                    
            
            

                
                    141
                

                                    
                                                    
                
                
                
		{smallSubTime(-30 * time.Second), "30 seconds ago", "en"},

            


            
                                                                        
                            
            
                                    
            
            

                
                    142
                

                                    
                                                    
                
                
                
		{smallSubTime(-31 * time.Second), "31 second ago", "en"},

            


            
                                                                        
                            
            
                                    
            
            

                
                    143
                

                                    
                                                    
                
                
                
		{smallSubTime(-59 * time.Second), "59 seconds ago", "en"},

            


            
                                                                        
                            
            
                                    
            
            

                
                    144
                

                                    
                                                    
                
                
                
		{smallSubTime(-60 * time.Second), "1 minute ago", "en"},

            


            
                                                                        
                            
            
                                    
            
            

                
                    145
                

                                    
                                                    
                
                
                
		{smallSubTime(-1 * time.Minute), "1 minute ago", "en"},

            


            
                                                                        
                            
            
                                    
            
            

                
                    146
                

                                    
                                                    
                
                
                
		{smallSubTime(-2 * time.Minute), "2 minutes ago", "en"},

            


            
                                                                        
                            
            
                                    
            
            

                
                    147
                

                                    
                                                    
                
                
                
		{smallSubTime(-9 * time.Minute), "9 minutes ago", "en"},

            


            
                                                                        
                            
            
                                    
            
            

                
                    148
                

                                    
                                                    
                
                
                
		{smallSubTime(-10 * time.Minute), "10 minutes ago", "en"},

            


            
                                                                        
                            
            
                                    
            
            

                
                    149
                

                                    
                                                    
                
                
                
		{smallSubTime(-11 * time.Minute), "11 minutes ago", "en"},

            


            
                                                                        
                            
            
                                    
            
            

                
                    150
                

                                    
                                                    
                
                
                
		{smallSubTime(-20 * time.Minute), "20 minutes ago", "en"},

            


            
                                                                        
                            
            
                                    
            
            

                
                    151
                

                                    
                                                    
                
                
                
		{smallSubTime(-21 * time.Minute), "21 minute ago", "en"},

            


            
                                                                        
                            
            
                                    
            
            

                
                    152
                

                                    
                                                    
                
                
                
		{smallSubTime(-22 * time.Minute), "22 minutes ago", "en"},

            


            
                                                                        
                            
            
                                    
            
            

                
                    153
                

                                    
                                                    
                
                
                
		{smallSubTime(-30 * time.Minute), "30 minutes ago", "en"},

            


            
                                                                        
                            
            
                                    
            
            

                
                    154
                

                                    
                                                    
                
                
                
		{smallSubTime(-31 * time.Minute), "31 minute ago", "en"},

            


            
                                                                        
                            
            
                                    
            
            

                
                    155
                

                                    
                                                    
                
                
                
		{smallSubTime(-59 * time.Minute), "59 minutes ago", "en"},

            


            
                                                                        
                            
            
                                    
            
            

                
                    156
                

                                    
                                                    
                
                
                
		{smallSubTime(-60 * time.Minute), "1 hour ago", "en"},

            


            
                                                                        
                            
            
                                    
            
            

                
                    157
                

                                    
                                                    
                
                
                
		{smallSubTime(-1 * time.Hour), "1 hour ago", "en"},

            


            
                                                                        
                            
            
                                    
            
            

                
                    158
                

                                    
                                                    
                
                
                
		{smallSubTime(-2 * time.Hour), "2 hours ago", "en"},

            


            
                                                                        
                            
            
                                    
            
            

                
                    159
                

                                    
                                                    
                
                
                
		{smallSubTime(-9 * time.Hour), "9 hours ago", "en"},

            


            
                                                                        
                            
            
                                    
            
            

                
                    160
                

                                    
                                                    
                
                
                
		{smallSubTime(-10 * time.Hour), "10 hours ago", "en"},

            


            
                                                                        
                            
            
                                    
            
            

                
                    161
                

                                    
                                                    
                
                
                
		{smallSubTime(-11 * time.Hour), "11 hours ago", "en"},

            


            
                                                                        
                            
            
                                    
            
            

                
                    162
                

                                    
                                                    
                
                
                
		{smallSubTime(-20 * time.Hour), "20 hours ago", "en"},

            


            
                                                                        
                            
            
                                    
            
            

                
                    163
                

                                    
                                                    
                
                
                
		{smallSubTime(-21 * time.Hour), "21 hour ago", "en"},

            


            
                                                                        
                            
            
                                    
            
            

                
                    164
                

                                    
                                                    
                
                
                
		{smallSubTime(-23 * time.Hour), "23 hours ago", "en"},

            


            
                                                                        
                            
            
                                    
            
            

                
                    165
                

                                    
                                                    
                
                
                
		{smallSubTime(-24 * time.Hour), "1 day ago", "en"},

            


            
                                                                        
                            
            
                                    
            
            

                
                    166
                

                                    
                                                    
                
                
                
		{smallSubTime(-47 * time.Hour), "1 day ago", "en"},

            


            
                                                                        
                            
            
                                    
            
            

                
                    167
                

                                    
                                                    
                
                
                
		{smallSubTime((-24 * 2) * time.Hour), "2 days ago", "en"},

            


            
                                                                        
                            
            
                                    
            
            

                
                    168
                

                                    
                                                    
                
                
                
		{smallSubTime((-24 * 6) * time.Hour), "6 days ago", "en"},

            


            
                                                                        
                            
            
                                    
            
            

                
                    169
                

                                    
                                                    
                
                
                
		{smallSubTime((-24 * 7) * time.Hour), "1 week ago", "en"},

            


            
                                                                        
                            
            
                                    
            
            

                
                    170
                

                                    
                                                    
                
                
                
		{smallSubTime((-24 * 14) * time.Hour), "2 weeks ago", "en"},

            


            
                                                                        
                            
            
                                    
            
            

                
                    171
                

                                    
                                                    
                
                
                
		{smallSubTime((-24 * 21) * time.Hour), "3 weeks ago", "en"},

            


            
                                                                        
                            
            
                                    
            
            

                
                    172
                

                                    
                                                    
                
                
                
		{bigSubTime(0, 1, 1), "1 month ago", "en"},

            


            
                                                                        
                            
            
                                    
            
            

                
                    173
                

                                    
                                                    
                
                
                
		{bigSubTime(0, 2, 1), "2 months ago", "en"},

            


            
                                                                        
                            
            
                                    
            
            

                
                    174
                

                                    
                                                    
                
                
                
		{bigSubTime(0, 9, 1), "9 months ago", "en"},

            


            
                                                                        
                            
            
                                    
            
            

                
                    175
                

                                    
                                                    
                
                
                
		{bigSubTime(0, 11, 1), "11 months ago", "en"},

            


            
                                                                        
                            
            
                                    
            
            

                
                    176
                

                                    
                                                    
                
                
                
		{bigSubTime(0, 12, 1), "1 year ago", "en"},

            


            
                                                                        
                            
            
                                    
            
            

                
                    177
                

                                    
                                                    
                
                
                
		{bigSubTime(1, 0, 1), "1 year ago", "en"},

            


            
                                                                        
                            
            
                                    
            
            

                
                    178
                

                                    
                                                    
                
                
                
		{bigSubTime(2, 0, 1), "2 years ago", "en"},

            


            
                                                                        
                            
            
                                    
            
            

                
                    179
                

                                    
                                                    
                
                
                
		{bigSubTime(21, 0, 1), "21 year ago", "en"},

            


            
                                                                        
                            
            
                                    
            
            

                
                    180
                

                                    
                                                    
                
                
                
		{bigSubTime(31, 0, 1), "31 year ago", "en"},

            


            
                                                                        
                            
            
                                    
            
            

                
                    181
                

                                    
                                                    
                
                
                
		{bigSubTime(100, 0, 1), "100 years ago", "en"},

            


            
                                                                        
                            
            
                                    
            
            

                
                    182
                

                                    
                                                    
                
                
                
		// russian

            


            
                                                                        
                            
            
                                    
            
            

                
                    183
                

                                    
                                                    
                
                
                
		{smallSubTime(time.Second * 2), "0 секунд назад", "ru"},

            


            
                                                                        
                            
            
                                    
            
            

                
                    184
                

                                    
                                                    
                
                
                
		{smallSubTime(time.Second), "0 секунд назад", "ru"},

            


            
                                                                        
                            
            
                                    
            
            

                
                    185
                

                                    
                                                    
                
                
                
		{smallSubTime(-1 * time.Second), "1 секунда назад", "ru"},

            


            
                                                                        
                            
            
                                    
            
            

                
                    186
                

                                    
                                                    
                
                
                
		{smallSubTime(-2 * time.Second), "2 секунды назад", "ru"},

            


            
                                                                        
                            
            
                                    
            
            

                
                    187
                

                                    
                                                    
                
                
                
		{smallSubTime(-9 * time.Second), "9 секунд назад", "ru"},

            


            
                                                                        
                            
            
                                    
            
            

                
                    188
                

                                    
                                                    
                
                
                
		{smallSubTime(-10 * time.Second), "10 секунд назад", "ru"},

            


            
                                                                        
                            
            
                                    
            
            

                
                    189
                

                                    
                                                    
                
                
                
		{smallSubTime(-11 * time.Second), "11 секунд назад", "ru"},

            


            
                                                                        
                            
            
                                    
            
            

                
                    190
                

                                    
                                                    
                
                
                
		{smallSubTime(-20 * time.Second), "20 секунд назад", "ru"},

            


            
                                                                        
                            
            
                                    
            
            

                
                    191
                

                                    
                                                    
                
                
                
		{smallSubTime(-21 * time.Second), "21 секунда назад", "ru"},

            


            
                                                                        
                            
            
                                    
            
            

                
                    192
                

                                    
                                                    
                
                
                
		{smallSubTime(-22 * time.Second), "22 секунды назад", "ru"},

            


            
                                                                        
                            
            
                                    
            
            

                
                    193
                

                                    
                                                    
                
                
                
		{smallSubTime(-30 * time.Second), "30 секунд назад", "ru"},

            


            
                                                                        
                            
            
                                    
            
            

                
                    194
                

                                    
                                                    
                
                
                
		{smallSubTime(-31 * time.Second), "31 секунда назад", "ru"},

            


            
                                                                        
                            
            
                                    
            
            

                
                    195
                

                                    
                                                    
                
                
                
		{smallSubTime(-59 * time.Second), "59 секунд назад", "ru"},

            


            
                                                                        
                            
            
                                    
            
            

                
                    196
                

                                    
                                                    
                
                
                
		{smallSubTime(-60 * time.Second), "1 минута назад", "ru"},

            


            
                                                                        
                            
            
                                    
            
            

                
                    197
                

                                    
                                                    
                
                
                
		{smallSubTime(-1 * time.Minute), "1 минута назад", "ru"},

            


            
                                                                        
                            
            
                                    
            
            

                
                    198
                

                                    
                                                    
                
                
                
		{smallSubTime(-2 * time.Minute), "2 минуты назад", "ru"},

            


            
                                                                        
                            
            
                                    
            
            

                
                    199
                

                                    
                                                    
                
                
                
		{smallSubTime(-9 * time.Minute), "9 минут назад", "ru"},

            


            
                                                                        
                            
            
                                    
            
            

                
                    200
                

                                    
                                                    
                
                
                
		{smallSubTime(-10 * time.Minute), "10 минут назад", "ru"},

            


            
                                                                        
                            
            
                                    
            
            

                
                    201
                

                                    
                                                    
                
                
                
		{smallSubTime(-11 * time.Minute), "11 минут назад", "ru"},

            


            
                                                                        
                            
            
                                    
            
            

                
                    202
                

                                    
                                                    
                
                
                
		{smallSubTime(-20 * time.Minute), "20 минут назад", "ru"},

            


            
                                                                        
                            
            
                                    
            
            

                
                    203
                

                                    
                                                    
                
                
                
		{smallSubTime(-21 * time.Minute), "21 минута назад", "ru"},

            


            
                                                                        
                            
            
                                    
            
            

                
                    204
                

                                    
                                                    
                
                
                
		{smallSubTime(-22 * time.Minute), "22 минуты назад", "ru"},

            


            
                                                                        
                            
            
                                    
            
            

                
                    205
                

                                    
                                                    
                
                
                
		{smallSubTime(-30 * time.Minute), "30 минут назад", "ru"},

            


            
                                                                        
                            
            
                                    
            
            

                
                    206
                

                                    
                                                    
                
                
                
		{smallSubTime(-31 * time.Minute), "31 минута назад", "ru"},

            


            
                                                                        
                            
            
                                    
            
            

                
                    207
                

                                    
                                                    
                
                
                
		{smallSubTime(-59 * time.Minute), "59 минут назад", "ru"},

            


            
                                                                        
                            
            
                                    
            
            

                
                    208
                

                                    
                                                    
                
                
                
		{smallSubTime(-60 * time.Minute), "1 час назад", "ru"},

            


            
                                                                        
                            
            
                                    
            
            

                
                    209
                

                                    
                                                    
                
                
                
		{smallSubTime(-1 * time.Hour), "1 час назад", "ru"},

            


            
                                                                        
                            
            
                                    
            
            

                
                    210
                

                                    
                                                    
                
                
                
		{smallSubTime(-2 * time.Hour), "2 часа назад", "ru"},

            


            
                                                                        
                            
            
                                    
            
            

                
                    211
                

                                    
                                                    
                
                
                
		{smallSubTime(-9 * time.Hour), "9 часов назад", "ru"},

            


            
                                                                        
                            
            
                                    
            
            

                
                    212
                

                                    
                                                    
                
                
                
		{smallSubTime(-10 * time.Hour), "10 часов назад", "ru"},

            


            
                                                                        
                            
            
                                    
            
            

                
                    213
                

                                    
                                                    
                
                
                
		{smallSubTime(-11 * time.Hour), "11 часов назад", "ru"},

            


            
                                                                        
                            
            
                                    
            
            

                
                    214
                

                                    
                                                    
                
                
                
		{smallSubTime(-20 * time.Hour), "20 часов назад", "ru"},

            


            
                                                                        
                            
            
                                    
            
            

                
                    215
                

                                    
                                                    
                
                
                
		{smallSubTime(-21 * time.Hour), "21 час назад", "ru"},

            


            
                                                                        
                            
            
                                    
            
            

                
                    216
                

                                    
                                                    
                
                
                
		{smallSubTime(-23 * time.Hour), "23 часа назад", "ru"},

            


            
                                                                        
                            
            
                                    
            
            

                
                    217
                

                                    
                                                    
                
                
                
		{smallSubTime(-24 * time.Hour), "1 день назад", "ru"},

            


            
                                                                        
                            
            
                                    
            
            

                
                    218
                

                                    
                                                    
                
                
                
		{smallSubTime(-47 * time.Hour), "1 день назад", "ru"},

            


            
                                                                        
                            
            
                                    
            
            

                
                    219
                

                                    
                                                    
                
                
                
		{smallSubTime((-24 * 2) * time.Hour), "2 дня назад", "ru"},

            


            
                                                                        
                            
            
                                    
            
            

                
                    220
                

                                    
                                                    
                
                
                
		{smallSubTime((-24 * 6) * time.Hour), "6 дней назад", "ru"},

            


            
                                                                        
                            
            
                                    
            
            

                
                    221
                

                                    
                                                    
                
                
                
		{smallSubTime((-24 * 7) * time.Hour), "1 неделя назад", "ru"},

            


            
                                                                        
                            
            
                                    
            
            

                
                    222
                

                                    
                                                    
                
                
                
		{smallSubTime((-24 * 14) * time.Hour), "2 недели назад", "ru"},

            


            
                                                                        
                            
            
                                    
            
            

                
                    223
                

                                    
                                                    
                
                
                
		{smallSubTime((-24 * 21) * time.Hour), "3 недели назад", "ru"},

            


            
                                                                        
                            
            
                                    
            
            

                
                    224
                

                                    
                                                    
                
                
                
		{bigSubTime(0, 1, 1), "1 месяц назад", "ru"},

            


            
                                                                        
                            
            
                                    
            
            

                
                    225
                

                                    
                                                    
                
                
                
		{bigSubTime(0, 2, 1), "2 месяца назад", "ru"},

            


            
                                                                        
                            
            
                                    
            
            

                
                    226
                

                                    
                                                    
                
                
                
		{bigSubTime(0, 9, 1), "9 месяцев назад", "ru"},

            


            
                                                                        
                            
            
                                    
            
            

                
                    227
                

                                    
                                                    
                
                
                
		{bigSubTime(0, 11, 1), "11 месяцев назад", "ru"},

            


            
                                                                        
                            
            
                                    
            
            

                
                    228
                

                                    
                                                    
                
                
                
		{bigSubTime(0, 12, 1), "1 год назад", "ru"},

            


            
                                                                        
                            
            
                                    
            
            

                
                    229
                

                                    
                                                    
                
                
                
		{bigSubTime(1, 0, 1), "1 год назад", "ru"},

            


            
                                                                        
                            
            
                                    
            
            

                
                    230
                

                                    
                                                    
                
                
                
		{bigSubTime(2, 0, 1), "2 года назад", "ru"},

            


            
                                                                        
                            
            
                                    
            
            

                
                    231
                

                                    
                                                    
                
                
                
		{bigSubTime(5, 0, 1), "5 лет назад", "ru"},

            


            
                                                                        
                            
            
                                    
            
            

                
                    232
                

                                    
                                                    
                
                
                
		{bigSubTime(6, 0, 1), "6 лет назад", "ru"},

            


            
                                                                        
                            
            
                                    
            
            

                
                    233
                

                                    
                                                    
                
                
                
		{bigSubTime(7, 0, 1), "7 лет назад", "ru"},

            


            
                                                                        
                            
            
                                    
            
            

                
                    234
                

                                    
                                                    
                
                
                
		{bigSubTime(21, 0, 1), "21 год назад", "ru"},

            


            
                                                                        
                            
            
                                    
            
            

                
                    235
                

                                    
                                                    
                
                
                
		{bigSubTime(31, 0, 1), "31 год назад", "ru"},

            


            
                                                                        
                            
            
                                    
            
            

                
                    236
                

                                    
                                                    
                
                
                
		{bigSubTime(100, 0, 1), "100 лет назад", "ru"},

            


            
                                                                        
                            
            
                                    
            
            

                
                    237
                

                                    
                                                    
                
                
                
	}

            


            
                                                                        
                            
            
                                    
            
            

                
                    238
                

                                    
                                                    
                
                
                

            


            
                                                                        
                            
            
                                    
            
            

                
                    239
                

                                    
                                                    
                
                
                
	for _, tc := range cases {

            


            
                                                                        
                            
            
                                    
            
            

                
                    240
                

                                    
                                                    
                
                
                
		t.Run("result for "+tc.date, func(test *testing.T) {

            


            
                                                                        
                            
            
                                    
            
            

                
                    241
                

                                    
                                                    
                
                
                
			Set("language", tc.lang)

            


            
                                                                        
                            
            
                                    
            
            

                
                    242
                

                                    
                                                    
                
                
                
			Set("location", "Europe/Kiev")

            


            
                                                                        
                            
            
                                    
            
            

                
                    243
                

                                    
                                                    
                
                
                

            


            
                                                                        
                            
            
                                    
            
            

                
                    244
                

                                    
                                                    
                
                
                
			if res := Take(tc.date); res != tc.result {

            


            
                                                                        
                            
            
                                    
            
            

                
                    245
                

                                    
                                                    
                
                
                
				test.Errorf("Result must be %s, but got %s instead", tc.result, res)

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    246
                

                                    
                                                    
                
                
                
			}

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    247
                

                                    
                                                    
                
                
                
		})

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    248
                

                                    
                                                    
                
                
                
	}

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    249
                

                                    
                                                    
                
                
                
}

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    250
                

                                    
                                                    
                
                
                

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    251
                

                                    
                                                    
                
                
                
func TestTake_with_online_flag(t *testing.T) {

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    252
                

                                    
                                                    
                
                
                
	cases := []struct {

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    253
                

                                    
                                                    
                
                
                
		date   string

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    254
                

                                    
                                                    
                
                
                
		result string

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    255
                

                                    
                                                    
                
                
                
		lang   string

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    256
                

                                    
                                                    
                
                
                
	}{

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    257
                

                                    
                                                    
                
                
                
		// english

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    258
                

                                    
                                                    
                
                
                
		{smallSubTime(time.Second * 2), "Online", "en"},

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    259
                

                                    
                                                    
                
                
                
		{smallSubTime(time.Second), "Online", "en"},

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    260
                

                                    
                                                    
                
                
                
		{smallSubTime(-1 * time.Second), "Online", "en"},

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    261
                

                                    
                                                    
                
                
                
		{smallSubTime(-2 * time.Second), "Online", "en"},

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    262
                

                                    
                                                    
                
                
                
		{smallSubTime(-9 * time.Second), "Online", "en"},

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    263
                

                                    
                                                    
                
                
                
		{smallSubTime(-10 * time.Second), "Online", "en"},

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    264
                

                                    
                                                    
                
                
                
		{smallSubTime(-11 * time.Second), "Online", "en"},

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    265
                

                                    
                                                    
                
                
                
		{smallSubTime(-20 * time.Second), "Online", "en"},

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    266
                

                                    
                                                    
                
                
                
		{smallSubTime(-21 * time.Second), "Online", "en"},

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    267
                

                                    
                                                    
                
                
                
		{smallSubTime(-22 * time.Second), "Online", "en"},

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    268
                

                                    
                                                    
                
                
                
		{smallSubTime(-30 * time.Second), "Online", "en"},

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    269
                

                                    
                                                    
                
                
                
		{smallSubTime(-31 * time.Second), "Online", "en"},

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    270
                

                                    
                                                    
                
                
                
		{smallSubTime(-59 * time.Second), "Online", "en"},

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    271
                

                                    
                                                    
                
                
                
		{smallSubTime(-60 * time.Second), "1 minute ago", "en"},

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    272
                

                                    
                                                    
                
                
                
		{smallSubTime(-1 * time.Minute), "1 minute ago", "en"},

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    273
                

                                    
                                                    
                
                
                
		{smallSubTime(-2 * time.Minute), "2 minutes ago", "en"},

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    274
                

                                    
                                                    
                
                
                
		{smallSubTime(-9 * time.Minute), "9 minutes ago", "en"},

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    275
                

                                    
                                                    
                
                
                
		{smallSubTime(-10 * time.Minute), "10 minutes ago", "en"},

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    276
                

                                    
                                                    
                
                
                
		{smallSubTime(-11 * time.Minute), "11 minutes ago", "en"},

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    277
                

                                    
                                                    
                
                
                
		{smallSubTime(-20 * time.Minute), "20 minutes ago", "en"},

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    278
                

                                    
                                                    
                
                
                
		{smallSubTime(-21 * time.Minute), "21 minute ago", "en"},

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    279
                

                                    
                                                    
                
                
                
		{smallSubTime(-22 * time.Minute), "22 minutes ago", "en"},

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    280
                

                                    
                                                    
                
                
                
		{smallSubTime(-30 * time.Minute), "30 minutes ago", "en"},

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    281
                

                                    
                                                    
                
                
                
		{smallSubTime(-31 * time.Minute), "31 minute ago", "en"},

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    282
                

                                    
                                                    
                
                
                
		{smallSubTime(-59 * time.Minute), "59 minutes ago", "en"},

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    283
                

                                    
                                                    
                
                
                
		{smallSubTime(-60 * time.Minute), "1 hour ago", "en"},

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    284
                

                                    
                                                    
                
                
                
		{smallSubTime(-1 * time.Hour), "1 hour ago", "en"},

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    285
                

                                    
                                                    
                
                
                
		{smallSubTime(-2 * time.Hour), "2 hours ago", "en"},

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    286
                

                                    
                                                    
                
                
                
		{smallSubTime(-9 * time.Hour), "9 hours ago", "en"},

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    287
                

                                    
                                                    
                
                
                
		{smallSubTime(-10 * time.Hour), "10 hours ago", "en"},

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    288
                

                                    
                                                    
                
                
                
		{smallSubTime(-11 * time.Hour), "11 hours ago", "en"},

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    289
                

                                    
                                                    
                
                
                
		{smallSubTime(-20 * time.Hour), "20 hours ago", "en"},

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    290
                

                                    
                                                    
                
                
                
		{smallSubTime(-21 * time.Hour), "21 hour ago", "en"},

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    291
                

                                    
                                                    
                
                
                
		{smallSubTime(-23 * time.Hour), "23 hours ago", "en"},

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    292
                

                                    
                                                    
                
                
                
		{smallSubTime(-24 * time.Hour), "1 day ago", "en"},

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    293
                

                                    
                                                    
                
                
                
		{smallSubTime(-47 * time.Hour), "1 day ago", "en"},

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    294
                

                                    
                                                    
                
                
                
		{smallSubTime((-24 * 2) * time.Hour), "2 days ago", "en"},

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    295
                

                                    
                                                    
                
                
                
		{smallSubTime((-24 * 6) * time.Hour), "6 days ago", "en"},

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    296
                

                                    
                                                    
                
                
                
		{smallSubTime((-24 * 7) * time.Hour), "1 week ago", "en"},

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    297
                

                                    
                                                    
                
                
                
		{smallSubTime((-24 * 14) * time.Hour), "2 weeks ago", "en"},

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    298
                

                                    
                                                    
                
                
                
		{smallSubTime((-24 * 21) * time.Hour), "3 weeks ago", "en"},

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    299
                

                                    
                                                    
                
                
                
		{bigSubTime(0, 1, 1), "1 month ago", "en"},

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    300
                

                                    
                                                    
                
                
                
		{bigSubTime(0, 2, 1), "2 months ago", "en"},

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    301
                

                                    
                                                    
                
                
                
		{bigSubTime(0, 9, 1), "9 months ago", "en"},

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    302
                

                                    
                                                    
                
                
                
		{bigSubTime(0, 11, 1), "11 months ago", "en"},

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    303
                

                                    
                                                    
                
                
                
		{bigSubTime(0, 12, 1), "1 year ago", "en"},

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    304
                

                                    
                                                    
                
                
                
		{bigSubTime(1, 0, 1), "1 year ago", "en"},

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    305
                

                                    
                                                    
                
                
                
		{bigSubTime(2, 0, 1), "2 years ago", "en"},

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    306
                

                                    
                                                    
                
                
                
		{bigSubTime(21, 0, 1), "21 year ago", "en"},

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    307
                

                                    
                                                    
                
                
                
		{bigSubTime(31, 0, 1), "31 year ago", "en"},

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    308
                

                                    
                                                    
                
                
                
		{bigSubTime(100, 0, 1), "100 years ago", "en"},

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    309
                

                                    
                                                    
                
                
                
		// russian

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    310
                

                                    
                                                    
                
                
                
		{smallSubTime(time.Second * 2), "В сети", "ru"},

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    311
                

                                    
                                                    
                
                
                
		{smallSubTime(time.Second), "В сети", "ru"},

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    312
                

                                    
                                                    
                
                
                
		{smallSubTime(-1 * time.Second), "В сети", "ru"},

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    313
                

                                    
                                                    
                
                
                
		{smallSubTime(-2 * time.Second), "В сети", "ru"},

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    314
                

                                    
                                                    
                
                
                
		{smallSubTime(-9 * time.Second), "В сети", "ru"},

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    315
                

                                    
                                                    
                
                
                
		{smallSubTime(-10 * time.Second), "В сети", "ru"},

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    316
                

                                    
                                                    
                
                
                
		{smallSubTime(-11 * time.Second), "В сети", "ru"},

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    317
                

                                    
                                                    
                
                
                
		{smallSubTime(-20 * time.Second), "В сети", "ru"},

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    318
                

                                    
                                                    
                
                
                
		{smallSubTime(-21 * time.Second), "В сети", "ru"},

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    319
                

                                    
                                                    
                
                
                
		{smallSubTime(-22 * time.Second), "В сети", "ru"},

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    320
                

                                    
                                                    
                
                
                
		{smallSubTime(-30 * time.Second), "В сети", "ru"},

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    321
                

                                    
                                                    
                
                
                
		{smallSubTime(-31 * time.Second), "В сети", "ru"},

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    322
                

                                    
                                                    
                
                
                
		{smallSubTime(-59 * time.Second), "В сети", "ru"},

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    323
                

                                    
                                                    
                
                
                
		{smallSubTime(-60 * time.Second), "1 минута назад", "ru"},

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    324
                

                                    
                                                    
                
                
                
		{smallSubTime(-1 * time.Minute), "1 минута назад", "ru"},

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    325
                

                                    
                                                    
                
                
                
		{smallSubTime(-2 * time.Minute), "2 минуты назад", "ru"},

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    326
                

                                    
                                                    
                
                
                
		{smallSubTime(-9 * time.Minute), "9 минут назад", "ru"},

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    327
                

                                    
                                                    
                
                
                
		{smallSubTime(-10 * time.Minute), "10 минут назад", "ru"},

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    328
                

                                    
                                                    
                
                
                
		{smallSubTime(-11 * time.Minute), "11 минут назад", "ru"},

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    329
                

                                    
                                                    
                
                
                
		{smallSubTime(-20 * time.Minute), "20 минут назад", "ru"},

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    330
                

                                    
                                                    
                
                
                
		{smallSubTime(-21 * time.Minute), "21 минута назад", "ru"},

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    331
                

                                    
                                                    
                
                
                
		{smallSubTime(-22 * time.Minute), "22 минуты назад", "ru"},

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    332
                

                                    
                                                    
                
                
                
		{smallSubTime(-30 * time.Minute), "30 минут назад", "ru"},

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    333
                

                                    
                                                    
                
                
                
		{smallSubTime(-31 * time.Minute), "31 минута назад", "ru"},

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    334
                

                                    
                                                    
                
                
                
		{smallSubTime(-59 * time.Minute), "59 минут назад", "ru"},

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    335
                

                                    
                                                    
                
                
                
		{smallSubTime(-60 * time.Minute), "1 час назад", "ru"},

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    336
                

                                    
                                                    
                
                
                
		{smallSubTime(-1 * time.Hour), "1 час назад", "ru"},

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    337
                

                                    
                                                    
                
                
                
		{smallSubTime(-2 * time.Hour), "2 часа назад", "ru"},

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    338
                

                                    
                                                    
                
                
                
		{smallSubTime(-9 * time.Hour), "9 часов назад", "ru"},

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    339
                

                                    
                                                    
                
                
                
		{smallSubTime(-10 * time.Hour), "10 часов назад", "ru"},

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    340
                

                                    
                                                    
                
                
                
		{smallSubTime(-11 * time.Hour), "11 часов назад", "ru"},

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    341
                

                                    
                                                    
                
                
                
		{smallSubTime(-20 * time.Hour), "20 часов назад", "ru"},

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    342
                

                                    
                                                    
                
                
                
		{smallSubTime(-21 * time.Hour), "21 час назад", "ru"},

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    343
                

                                    
                                                    
                
                
                
		{smallSubTime(-23 * time.Hour), "23 часа назад", "ru"},

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    344
                

                                    
                                                    
                
                
                
		{smallSubTime(-24 * time.Hour), "1 день назад", "ru"},

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    345
                

                                    
                                                    
                
                
                
		{smallSubTime(-47 * time.Hour), "1 день назад", "ru"},

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    346
                

                                    
                                                    
                
                
                
		{smallSubTime((-24 * 2) * time.Hour), "2 дня назад", "ru"},

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    347
                

                                    
                                                    
                
                
                
		{smallSubTime((-24 * 6) * time.Hour), "6 дней назад", "ru"},

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    348
                

                                    
                                                    
                
                
                
		{smallSubTime((-24 * 7) * time.Hour), "1 неделя назад", "ru"},

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    349
                

                                    
                                                    
                
                
                
		{smallSubTime((-24 * 14) * time.Hour), "2 недели назад", "ru"},

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    350
                

                                    
                                                    
                
                
                
		{smallSubTime((-24 * 21) * time.Hour), "3 недели назад", "ru"},

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    351
                

                                    
                                                    
                
                
                
		{bigSubTime(0, 1, 1), "1 месяц назад", "ru"},

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    352
                

                                    
                                                    
                
                
                
		{bigSubTime(0, 2, 1), "2 месяца назад", "ru"},

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    353
                

                                    
                                                    
                
                
                
		{bigSubTime(0, 9, 1), "9 месяцев назад", "ru"},

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    354
                

                                    
                                                    
                
                
                
		{bigSubTime(0, 11, 1), "11 месяцев назад", "ru"},

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    355
                

                                    
                                                    
                
                
                
		{bigSubTime(0, 12, 1), "1 год назад", "ru"},

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    356
                

                                    
                                                    
                
                
                
		{bigSubTime(1, 0, 1), "1 год назад", "ru"},

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    357
                

                                    
                                                    
                
                
                
		{bigSubTime(2, 0, 1), "2 года назад", "ru"},

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    358
                

                                    
                                                    
                
                
                
		{bigSubTime(5, 0, 1), "5 лет назад", "ru"},

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    359
                

                                    
                                                    
                
                
                
		{bigSubTime(6, 0, 1), "6 лет назад", "ru"},

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    360
                

                                    
                                                    
                
                
                
		{bigSubTime(7, 0, 1), "7 лет назад", "ru"},

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    361
                

                                    
                                                    
                
                
                
		{bigSubTime(21, 0, 1), "21 год назад", "ru"},

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    362
                

                                    
                                                    
                
                
                
		{bigSubTime(31, 0, 1), "31 год назад", "ru"},

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    363
                

                                    
                                                    
                
                
                
		{bigSubTime(100, 0, 1), "100 лет назад", "ru"},

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    364
                

                                    
                                                    
                
                
                
	}

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    365
                

                                    
                                                    
                
                
                

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    366
                

                                    
                                                    
                
                
                
	for _, tc := range cases {

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    367
                

                                    
                                                    
                
                
                
		t.Run("result for "+tc.date+"|online", func(test *testing.T) {

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    368
                

                                    
                                                    
                
                
                
			Set("language", tc.lang)

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    369
                

                                    
                                                    
                
                
                

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    370
                

                                    
                                                    
                
                
                
			if res := Take(tc.date + "|online"); res != tc.result {

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    371
                

                                    
                                                    
                
                
                
				test.Errorf("Result must be %s, but got %s instead", tc.result, res)

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    372
                

                                    
                                                    
                
                
                
			}

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    373
                

                                    
                                                    
                
                
                
		})

            


            
                                                                                                            
                            
            
                                    
            
            

                
                    374
                

                                    
                                                    
                
                
                
	}

            


            
                                                                                                            
                                                                
            
                                    
            
            

                
                    375
                

                                    
                                                    
                
                
                
}

            


            
                                                        
            
                                    
            
            

                
                    376