locker_test.go 2.0 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124
  1. package locker
  2. import (
  3. "sync"
  4. "testing"
  5. "time"
  6. )
  7. func TestLockCounter(t *testing.T) {
  8. l := &lockCtr{}
  9. l.inc()
  10. if l.waiters != 1 {
  11. t.Fatal("counter inc failed")
  12. }
  13. l.dec()
  14. if l.waiters != 0 {
  15. t.Fatal("counter dec failed")
  16. }
  17. }
  18. func TestLockerLock(t *testing.T) {
  19. l := New()
  20. l.Lock("test")
  21. ctr := l.locks["test"]
  22. if ctr.count() != 0 {
  23. t.Fatalf("expected waiters to be 0, got :%d", ctr.waiters)
  24. }
  25. chDone := make(chan struct{})
  26. go func() {
  27. l.Lock("test")
  28. close(chDone)
  29. }()
  30. chWaiting := make(chan struct{})
  31. go func() {
  32. for range time.Tick(1 * time.Millisecond) {
  33. if ctr.count() == 1 {
  34. close(chWaiting)
  35. break
  36. }
  37. }
  38. }()
  39. select {
  40. case <-chWaiting:
  41. case <-time.After(3 * time.Second):
  42. t.Fatal("timed out waiting for lock waiters to be incremented")
  43. }
  44. select {
  45. case <-chDone:
  46. t.Fatal("lock should not have returned while it was still held")
  47. default:
  48. }
  49. if err := l.Unlock("test"); err != nil {
  50. t.Fatal(err)
  51. }
  52. select {
  53. case <-chDone:
  54. case <-time.After(3 * time.Second):
  55. t.Fatalf("lock should have completed")
  56. }
  57. if ctr.count() != 0 {
  58. t.Fatalf("expected waiters to be 0, got: %d", ctr.count())
  59. }
  60. }
  61. func TestLockerUnlock(t *testing.T) {
  62. l := New()
  63. l.Lock("test")
  64. l.Unlock("test")
  65. chDone := make(chan struct{})
  66. go func() {
  67. l.Lock("test")
  68. close(chDone)
  69. }()
  70. select {
  71. case <-chDone:
  72. case <-time.After(3 * time.Second):
  73. t.Fatalf("lock should not be blocked")
  74. }
  75. }
  76. func TestLockerConcurrency(t *testing.T) {
  77. l := New()
  78. var wg sync.WaitGroup
  79. for i := 0; i <= 10000; i++ {
  80. wg.Add(1)
  81. go func() {
  82. l.Lock("test")
  83. // if there is a concurrency issue, will very likely panic here
  84. l.Unlock("test")
  85. wg.Done()
  86. }()
  87. }
  88. chDone := make(chan struct{})
  89. go func() {
  90. wg.Wait()
  91. close(chDone)
  92. }()
  93. select {
  94. case <-chDone:
  95. case <-time.After(10 * time.Second):
  96. t.Fatal("timeout waiting for locks to complete")
  97. }
  98. // Since everything has unlocked this should not exist anymore
  99. if ctr, exists := l.locks["test"]; exists {
  100. t.Fatalf("lock should not exist: %v", ctr)
  101. }
  102. }