hunk.code_window: 		require.Nil(t, err)
   		assert.Equal(t, count, countResult)
   		mockStore.Channel().(*mocks.ChannelStore).AssertNumberOfCalls(t, "GetPinnedPostCount", 1)
   	})
   	t.Run("first call not cached, second force no cached", func(t *testing.T) {
   		mockStore := getMockStore()
   		cachedStore := NewLocalCacheLayer(mockStore, nil, nil)
   		cachedStore.Channel().GetPinnedPostCount("id", true)
   		mockStore.Channel().(*mocks.ChannelStore).AssertNumberOfCalls(t, "GetPinnedPostCount", 1)
  
hunk.labels: keep keep keep keep keep replace keep keep keep keep keep
hunk.after_edit: 	t.Run("first call not cached, second force not cached", func(t *testing.T) {
  
hunk.file_path: store/localcachelayer/channel_layer_test.go
hunk.type: replace
file: package dns
  
  // Holds a bunch of helper functions for dealing with labels.
  
  // SplitDomainName splits a name string into it's labels.
  // www.miek.nl. returns []string{"www", "miek", "nl"}
  // .www.miek.nl. returns []string{"", "www", "miek", "nl"},
  // The root label (.) returns nil. Note that using
  // strings.Split(s) will work in most cases, but does not handle
  // escaped dots (\.) for instance.
  // s must be a syntactically valid domain name, see IsDomainName.
  func SplitDomainName(s string) (labels []string) {
  	if len(s) == 0 {
  		return nil
  	}
  	if s == "." {
  		return nil
  	}
  	// offset of the final '.' or the length of the name
  	var fqdnEnd int
  	if IsFqdn(s) {
  		fqdnEnd = len(s) - 1
  	} else {
  		fqdnEnd = len(s)
  	}
  	var (
  		begin int
  		off   int
  		end   bool
  	)
  	for {
  		off, end = NextLabel(s, off)
  		if end {
  			break
  		}
  		labels = append(labels, s[begin:off-1])
  		begin = off
  	}
  	return append(labels, s[begin:fqdnEnd])
  }
  
  // CompareDomainName compares the names s1 and s2 and
  // returns how many labels they have in common starting from the *right*.
  // The comparison stops at the first inequality. The names are downcased
  // before the comparison.
  //
  // www.miek.nl. and miek.nl. have two labels in common: miek and nl
  // www.miek.nl. and www.bla.nl. have one label in common: nl
  //
  // s1 and s2 must be syntactically valid domain names.
  func CompareDomainName(s1, s2 string) (n int) {
  	// the first check: root label
  	if s1 == "." || s2 == "." {
  		return 0
  	}
  
  	j1 := len(s1)
  	if s1[j1-1] == '.' {
  		j1--
  	}
  	j2 := len(s2)
  	if s2[j2-1] == '.' {
  		j2--
  	}
  	var i1, i2 int
  	for {
  		i1 = prevLabel(s1, j1-1)
  		i2 = prevLabel(s2, j2-1)
  		if equal(s1[i1:j1], s2[i2:j2]) {
  			n++
  		} else {
  			break
  		}
  		if i1 == 0 || i2 == 0 {
  			break
  		}
  		j1 = i1 - 2
  		j2 = i2 - 2
  	}
  	return
  }
  
  // CountLabel counts the the number of labels in the string s.
  // s must be a syntactically valid domain name.
  func CountLabel(s string) int {
  	if s == "." {
  		return 0
  	}
  	labels := 1
  	for i := 0; i < len(s)-1; i++ {
  		c := s[i]
  		if c == '\\' {
  			i++
  			continue
  		}
  		if c == '.' {
  			labels++
  		}
  	}
  	return labels
  }
  
  // Split splits a name s into its label indexes.
  // www.miek.nl. returns []int{0, 4, 9}, www.miek.nl also returns []int{0, 4, 9}.
  // The root name (.) returns nil. Also see SplitDomainName.
  // s must be a syntactically valid domain name.
  func Split(s string) []int {
  	if s == "." {
  		return nil
  	}
  	idx := make([]int, 1, 3)
  	off := 0
  	end := false
  
  	for {
  		off, end = NextLabel(s, off)
  		if end {
  			return idx
  		}
  		idx = append(idx, off)
  	}
  }
  
  // NextLabel returns the index of the start of the next label in the
  // string s starting at offset.
  // The bool end is true when the end of the string has been reached.
  // Also see PrevLabel.
  func NextLabel(s string, offset int) (i int, end bool) {
  	for i = offset; i < len(s)-1; i++ {
  		c := s[i]
  		if c == '\\' {
  			i++
  			continue
  		}
  		if c == '.' {
  			return i + 1, false
  		}
  	}
  	return i + 1, true
  }
  
  func prevLabel(s string, offset int) int {
  	for i := offset; i >= 0; i-- {
  		if s[i] == '.' {
  			if i == 0 || s[i-1] != '\\' {
  				return i + 1 // the '.' is not escaped
  			}
  			// We are at '\.' and need to check if the '\' itself is escaped.
  			// We do this by walking backwards from '\.' and counting the
  			// number of '\' we encounter.  If the number of '\' is even
  			// (though here it's actually odd since we start at '\.') the '\'
  			// is escaped.
  			j := i - 2
  			for ; j >= 0 && s[j] == '\\'; j-- {
  			}
  			// An odd number here indicates that the '\' preceding the '.'
  			// is escaped.
  			if (i-j)&1 == 1 {
  				return i + 1
  			}
  			i = j + 1
  		}
  	}
  	return 0
  }
  
  // PrevLabel returns the index of the label when starting from the right and
  // jumping n labels to the left.
  // The bool start is true when the start of the string has been overshot.
  // Also see NextLabel.
  func PrevLabel(s string, n int) (i int, start bool) {
  	if s == "." {
  		return 0, true
  	}
  	if n == 0 {
  		return len(s), false
  	}
  	i = len(s) - 1
  	if s[i] == '.' {
  		i--
  	}
  	for ; n > 0; n-- {
  		i = prevLabel(s, i)
  		if i == 0 {
  			break
  		}
  		i -= 2
  	}
  	if n > 0 {
  		return 0, true
  	}
  	return i + 2, false
  }
  
  // equal compares a and b while ignoring case. It returns true when equal otherwise false.
  func equal(a, b string) bool {
  	// might be lifted into API function.
  	la := len(a)
  	lb := len(b)
  	if la != lb {
  		return false
  	}
  	if a != b {
  		// case-insensitive comparison
  		for i := la - 1; i >= 0; i-- {
  			ai := a[i]
  			bi := b[i]
  			if ai != bi {
  				if bi < ai {
  					bi, ai = ai, bi
  				}
  				if !('A' <= ai && ai <= 'Z' && bi == ai+'a'-'A') {
  					return false
  				}
  			}
  		}
  	}
  	return true
  }
  