hunk.code_window: const dispatch = store.dispatch;
   const getState = store.getState;
   import {removeUserFromTeam} from 'mattermost-redux/actions/teams';
   import {viewChannel, getChannelStats, getMyChannelMember} from 'mattermost-redux/actions/channels';
   export function emitChannelClickEvent(channel) {
       function userVisitedFakeChannel(chan, success, fail) {
  
hunk.labels: keep keep keep replace keep keep keep
hunk.after_edit: import {viewChannel, getChannelStats, getMyChannelMember, getChannelAndMyMember} from 'mattermost-redux/actions/channels';
  
hunk.file_path: webapp/actions/global_actions.jsx
hunk.type: replace
file: // Copyright 2014 The Go Authors. All rights reserved.
  // Use of this source code is governed by a BSD-style
  // license that can be found in the LICENSE file.
  
  package hpack
  
  import (
  	"bytes"
  	"encoding/hex"
  	"fmt"
  	"math/rand"
  	"reflect"
  	"strings"
  	"testing"
  )
  
  func TestEncoderTableSizeUpdate(t *testing.T) {
  	tests := []struct {
  		size1, size2 uint32
  		wantHex      string
  	}{
  		// Should emit 2 table size updates (2048 and 4096)
  		{2048, 4096, "3fe10f 3fe11f 82"},
  
  		// Should emit 1 table size update (2048)
  		{16384, 2048, "3fe10f 82"},
  	}
  	for _, tt := range tests {
  		var buf bytes.Buffer
  		e := NewEncoder(&buf)
  		e.SetMaxDynamicTableSize(tt.size1)
  		e.SetMaxDynamicTableSize(tt.size2)
  		if err := e.WriteField(pair(":method", "GET")); err != nil {
  			t.Fatal(err)
  		}
  		want := removeSpace(tt.wantHex)
  		if got := hex.EncodeToString(buf.Bytes()); got != want {
  			t.Errorf("e.SetDynamicTableSize %v, %v = %q; want %q", tt.size1, tt.size2, got, want)
  		}
  	}
  }
  
  func TestEncoderWriteField(t *testing.T) {
  	var buf bytes.Buffer
  	e := NewEncoder(&buf)
  	var got []HeaderField
  	d := NewDecoder(4<<10, func(f HeaderField) {
  		got = append(got, f)
  	})
  
  	tests := []struct {
  		hdrs []HeaderField
  	}{
  		{[]HeaderField{
  			pair(":method", "GET"),
  			pair(":scheme", "http"),
  			pair(":path", "/"),
  			pair(":authority", "www.example.com"),
  		}},
  		{[]HeaderField{
  			pair(":method", "GET"),
  			pair(":scheme", "http"),
  			pair(":path", "/"),
  			pair(":authority", "www.example.com"),
  			pair("cache-control", "no-cache"),
  		}},
  		{[]HeaderField{
  			pair(":method", "GET"),
  			pair(":scheme", "https"),
  			pair(":path", "/index.html"),
  			pair(":authority", "www.example.com"),
  			pair("custom-key", "custom-value"),
  		}},
  	}
  	for i, tt := range tests {
  		buf.Reset()
  		got = got[:0]
  		for _, hf := range tt.hdrs {
  			if err := e.WriteField(hf); err != nil {
  				t.Fatal(err)
  			}
  		}
  		_, err := d.Write(buf.Bytes())
  		if err != nil {
  			t.Errorf("%d. Decoder Write = %v", i, err)
  		}
  		if !reflect.DeepEqual(got, tt.hdrs) {
  			t.Errorf("%d. Decoded %+v; want %+v", i, got, tt.hdrs)
  		}
  	}
  }
  
  func TestEncoderSearchTable(t *testing.T) {
  	e := NewEncoder(nil)
  
  	e.dynTab.add(pair("foo", "bar"))
  	e.dynTab.add(pair("blake", "miz"))
  	e.dynTab.add(pair(":method", "GET"))
  
  	tests := []struct {
  		hf        HeaderField
  		wantI     uint64
  		wantMatch bool
  	}{
  		// Name and Value match
  		{pair("foo", "bar"), uint64(staticTable.len()) + 3, true},
  		{pair("blake", "miz"), uint64(staticTable.len()) + 2, true},
  		{pair(":method", "GET"), 2, true},
  
  		// Only name match because Sensitive == true. This is allowed to match
  		// any ":method" entry. The current implementation uses the last entry
  		// added in newStaticTable.
  		{HeaderField{":method", "GET", true}, 3, false},
  
  		// Only Name matches
  		{pair("foo", "..."), uint64(staticTable.len()) + 3, false},
  		{pair("blake", "..."), uint64(staticTable.len()) + 2, false},
  		// As before, this is allowed to match any ":method" entry.
  		{pair(":method", "..."), 3, false},
  
  		// None match
  		{pair("foo-", "bar"), 0, false},
  	}
  	for _, tt := range tests {
  		if gotI, gotMatch := e.searchTable(tt.hf); gotI != tt.wantI || gotMatch != tt.wantMatch {
  			t.Errorf("d.search(%+v) = %v, %v; want %v, %v", tt.hf, gotI, gotMatch, tt.wantI, tt.wantMatch)
  		}
  	}
  }
  
  func TestAppendVarInt(t *testing.T) {
  	tests := []struct {
  		n    byte
  		i    uint64
  		want []byte
  	}{
  		// Fits in a byte:
  		{1, 0, []byte{0}},
  		{2, 2, []byte{2}},
  		{3, 6, []byte{6}},
  		{4, 14, []byte{14}},
  		{5, 30, []byte{30}},
  		{6, 62, []byte{62}},
  		{7, 126, []byte{126}},
  		{8, 254, []byte{254}},
  
  		// Multiple bytes:
  		{5, 1337, []byte{31, 154, 10}},
  	}
  	for _, tt := range tests {
  		got := appendVarInt(nil, tt.n, tt.i)
  		if !bytes.Equal(got, tt.want) {
  			t.Errorf("appendVarInt(nil, %v, %v) = %v; want %v", tt.n, tt.i, got, tt.want)
  		}
  	}
  }
  
  func TestAppendHpackString(t *testing.T) {
  	tests := []struct {
  		s, wantHex string
  	}{
  		// Huffman encoded
  		{"www.example.com", "8c f1e3 c2e5 f23a 6ba0 ab90 f4ff"},
  
  		// Not Huffman encoded
  		{"a", "01 61"},
  
  		// zero length
  		{"", "00"},
  	}
  	for _, tt := range tests {
  		want := removeSpace(tt.wantHex)
  		buf := appendHpackString(nil, tt.s)
  		if got := hex.EncodeToString(buf); want != got {
  			t.Errorf("appendHpackString(nil, %q) = %q; want %q", tt.s, got, want)
  		}
  	}
  }
  
  func TestAppendIndexed(t *testing.T) {
  	tests := []struct {
  		i       uint64
  		wantHex string
  	}{
  		// 1 byte
  		{1, "81"},
  		{126, "fe"},
  
  		// 2 bytes
  		{127, "ff00"},
  		{128, "ff01"},
  	}
  	for _, tt := range tests {
  		want := removeSpace(tt.wantHex)
  		buf := appendIndexed(nil, tt.i)
  		if got := hex.EncodeToString(buf); want != got {
  			t.Errorf("appendIndex(nil, %v) = %q; want %q", tt.i, got, want)
  		}
  	}
  }
  
  func TestAppendNewName(t *testing.T) {
  	tests := []struct {
  		f        HeaderField
  		indexing bool
  		wantHex  string
  	}{
  		// Incremental indexing
  		{HeaderField{"custom-key", "custom-value", false}, true, "40 88 25a8 49e9 5ba9 7d7f 89 25a8 49e9 5bb8 e8b4 bf"},
  
  		// Without indexing
  		{HeaderField{"custom-key", "custom-value", false}, false, "00 88 25a8 49e9 5ba9 7d7f 89 25a8 49e9 5bb8 e8b4 bf"},
  
  		// Never indexed
  		{HeaderField{"custom-key", "custom-value", true}, true, "10 88 25a8 49e9 5ba9 7d7f 89 25a8 49e9 5bb8 e8b4 bf"},
  		{HeaderField{"custom-key", "custom-value", true}, false, "10 88 25a8 49e9 5ba9 7d7f 89 25a8 49e9 5bb8 e8b4 bf"},
  	}
  	for _, tt := range tests {
  		want := removeSpace(tt.wantHex)
  		buf := appendNewName(nil, tt.f, tt.indexing)
  		if got := hex.EncodeToString(buf); want != got {
  			t.Errorf("appendNewName(nil, %+v, %v) = %q; want %q", tt.f, tt.indexing, got, want)
  		}
  	}
  }
  
  func TestAppendIndexedName(t *testing.T) {
  	tests := []struct {
  		f        HeaderField
  		i        uint64
  		indexing bool
  		wantHex  string
  	}{
  		// Incremental indexing
  		{HeaderField{":status", "302", false}, 8, true, "48 82 6402"},
  
  		// Without indexing
  		{HeaderField{":status", "302", false}, 8, false, "08 82 6402"},
  
  		// Never indexed
  		{HeaderField{":status", "302", true}, 8, true, "18 82 6402"},
  		{HeaderField{":status", "302", true}, 8, false, "18 82 6402"},
  	}
  	for _, tt := range tests {
  		want := removeSpace(tt.wantHex)
  		buf := appendIndexedName(nil, tt.f, tt.i, tt.indexing)
  		if got := hex.EncodeToString(buf); want != got {
  			t.Errorf("appendIndexedName(nil, %+v, %v) = %q; want %q", tt.f, tt.indexing, got, want)
  		}
  	}
  }
  
  func TestAppendTableSize(t *testing.T) {
  	tests := []struct {
  		i       uint32
  		wantHex string
  	}{
  		// Fits into 1 byte
  		{30, "3e"},
  
  		// Extra byte
  		{31, "3f00"},
  		{32, "3f01"},
  	}
  	for _, tt := range tests {
  		want := removeSpace(tt.wantHex)
  		buf := appendTableSize(nil, tt.i)
  		if got := hex.EncodeToString(buf); want != got {
  			t.Errorf("appendTableSize(nil, %v) = %q; want %q", tt.i, got, want)
  		}
  	}
  }
  
  func TestEncoderSetMaxDynamicTableSize(t *testing.T) {
  	var buf bytes.Buffer
  	e := NewEncoder(&buf)
  	tests := []struct {
  		v           uint32
  		wantUpdate  bool
  		wantMinSize uint32
  		wantMaxSize uint32
  	}{
  		// Set new table size to 2048
  		{2048, true, 2048, 2048},
  
  		// Set new table size to 16384, but still limited to
  		// 4096
  		{16384, true, 2048, 4096},
  	}
  	for _, tt := range tests {
  		e.SetMaxDynamicTableSize(tt.v)
  		if got := e.tableSizeUpdate; tt.wantUpdate != got {
  			t.Errorf("e.tableSizeUpdate = %v; want %v", got, tt.wantUpdate)
  		}
  		if got := e.minSize; tt.wantMinSize != got {
  			t.Errorf("e.minSize = %v; want %v", got, tt.wantMinSize)
  		}
  		if got := e.dynTab.maxSize; tt.wantMaxSize != got {
  			t.Errorf("e.maxSize = %v; want %v", got, tt.wantMaxSize)
  		}
  	}
  }
  
  func TestEncoderSetMaxDynamicTableSizeLimit(t *testing.T) {
  	e := NewEncoder(nil)
  	// 4095 < initialHeaderTableSize means maxSize is truncated to
  	// 4095.
  	e.SetMaxDynamicTableSizeLimit(4095)
  	if got, want := e.dynTab.maxSize, uint32(4095); got != want {
  		t.Errorf("e.dynTab.maxSize = %v; want %v", got, want)
  	}
  	if got, want := e.maxSizeLimit, uint32(4095); got != want {
  		t.Errorf("e.maxSizeLimit = %v; want %v", got, want)
  	}
  	if got, want := e.tableSizeUpdate, true; got != want {
  		t.Errorf("e.tableSizeUpdate = %v; want %v", got, want)
  	}
  	// maxSize will be truncated to maxSizeLimit
  	e.SetMaxDynamicTableSize(16384)
  	if got, want := e.dynTab.maxSize, uint32(4095); got != want {
  		t.Errorf("e.dynTab.maxSize = %v; want %v", got, want)
  	}
  	// 8192 > current maxSizeLimit, so maxSize does not change.
  	e.SetMaxDynamicTableSizeLimit(8192)
  	if got, want := e.dynTab.maxSize, uint32(4095); got != want {
  		t.Errorf("e.dynTab.maxSize = %v; want %v", got, want)
  	}
  	if got, want := e.maxSizeLimit, uint32(8192); got != want {
  		t.Errorf("e.maxSizeLimit = %v; want %v", got, want)
  	}
  }
  
  func removeSpace(s string) string {
  	return strings.Replace(s, " ", "", -1)
  }
  
  func BenchmarkEncoderSearchTable(b *testing.B) {
  	e := NewEncoder(nil)
  
  	// A sample of possible header fields.
  	// This is not based on any actual data from HTTP/2 traces.
  	var possible []HeaderField
  	for _, f := range staticTable.ents {
  		if f.Value == "" {
  			possible = append(possible, f)
  			continue
  		}
  		// Generate 5 random values, except for cookie and set-cookie,
  		// which we know can have many values in practice.
  		num := 5
  		if f.Name == "cookie" || f.Name == "set-cookie" {
  			num = 25
  		}
  		for i := 0; i < num; i++ {
  			f.Value = fmt.Sprintf("%s-%d", f.Name, i)
  			possible = append(possible, f)
  		}
  	}
  	for k := 0; k < 10; k++ {
  		f := HeaderField{
  			Name:      fmt.Sprintf("x-header-%d", k),
  			Sensitive: rand.Int()%2 == 0,
  		}
  		for i := 0; i < 5; i++ {
  			f.Value = fmt.Sprintf("%s-%d", f.Name, i)
  			possible = append(possible, f)
  		}
  	}
  
  	// Add a random sample to the dynamic table. This very loosely simulates
  	// a history of 100 requests with 20 header fields per request.
  	for r := 0; r < 100*20; r++ {
  		f := possible[rand.Int31n(int32(len(possible)))]
  		// Skip if this is in the staticTable verbatim.
  		if _, has := staticTable.search(f); !has {
  			e.dynTab.add(f)
  		}
  	}
  
  	b.ResetTimer()
  	for n := 0; n < b.N; n++ {
  		for _, f := range possible {
  			e.searchTable(f)
  		}
  	}
  }
  