From 26f57daf23ad39ea5374b87726a33a108db1af73 Mon Sep 17 00:00:00 2001 From: Noah Metz Date: Sun, 25 Jun 2023 22:23:57 -0600 Subject: [PATCH] Changed NewLockable to NewBaseLockable --- lockable.go | 2 +- lockable_test.go | 50 ++++++++++++++++++++++++------------------------ thread_test.go | 2 +- 3 files changed, 27 insertions(+), 27 deletions(-) diff --git a/lockable.go b/lockable.go index f5244b6..80cf847 100644 --- a/lockable.go +++ b/lockable.go @@ -429,7 +429,7 @@ func (lockable * BaseLockable) Unlock(node GraphNode, state LockableState) error return nil } -func NewLockable(ctx * GraphContext, name string, requirements []Lockable) (* BaseLockable, error) { +func NewBaseLockable(ctx * GraphContext, name string, requirements []Lockable) (* BaseLockable, error) { state := NewBaseLockableState(name) lockable := &BaseLockable{ BaseNode: NewNode(ctx, RandID(), &state), diff --git a/lockable_test.go b/lockable_test.go index 829b483..d059615 100644 --- a/lockable_test.go +++ b/lockable_test.go @@ -7,23 +7,23 @@ import ( "time" ) -func TestNewLockable(t * testing.T) { +func TestNewBaseLockable(t * testing.T) { ctx := testContext(t) - r1, err := NewLockable(ctx, "Test lockable 1", []Lockable{}) + r1, err := NewBaseLockable(ctx, "Test lockable 1", []Lockable{}) fatalErr(t, err) - _, err = NewLockable(ctx, "Test lockable 2", []Lockable{r1}) + _, err = NewBaseLockable(ctx, "Test lockable 2", []Lockable{r1}) fatalErr(t, err) } func TestRepeatedChildLockable(t * testing.T) { ctx := testContext(t) - r1, err := NewLockable(ctx, "Test lockable 1", []Lockable{}) + r1, err := NewBaseLockable(ctx, "Test lockable 1", []Lockable{}) fatalErr(t, err) - _, err = NewLockable(ctx, "Test lockable 2", []Lockable{r1, r1}) + _, err = NewBaseLockable(ctx, "Test lockable 2", []Lockable{r1, r1}) if err == nil { t.Fatal("Added the same lockable as a child twice to the same lockable") } @@ -32,7 +32,7 @@ func TestRepeatedChildLockable(t * testing.T) { func TestLockableSelfLock(t * testing.T) { ctx := testContext(t) - r1, err := NewLockable(ctx, "Test lockable 1", []Lockable{}) + r1, err := NewBaseLockable(ctx, "Test lockable 1", []Lockable{}) fatalErr(t, err) err = LockLockable(ctx, r1, r1, nil) @@ -64,13 +64,13 @@ func TestLockableSelfLock(t * testing.T) { func TestLockableSelfLockTiered(t * testing.T) { ctx := testContext(t) - r1, err := NewLockable(ctx, "Test lockable 1", []Lockable{}) + r1, err := NewBaseLockable(ctx, "Test lockable 1", []Lockable{}) fatalErr(t, err) - r2, err := NewLockable(ctx, "Test lockable 2", []Lockable{}) + r2, err := NewBaseLockable(ctx, "Test lockable 2", []Lockable{}) fatalErr(t, err) - r3, err := NewLockable(ctx, "Test lockable 3", []Lockable{r1, r2}) + r3, err := NewBaseLockable(ctx, "Test lockable 3", []Lockable{r1, r2}) fatalErr(t, err) err = LockLockable(ctx, r3, r3, nil) @@ -120,10 +120,10 @@ func TestLockableSelfLockTiered(t * testing.T) { func TestLockableLockOther(t * testing.T) { ctx := testContext(t) - r1, err := NewLockable(ctx, "Test lockable 1", []Lockable{}) + r1, err := NewBaseLockable(ctx, "Test lockable 1", []Lockable{}) fatalErr(t, err) - r2, err := NewLockable(ctx, "Test lockable 2", []Lockable{}) + r2, err := NewBaseLockable(ctx, "Test lockable 2", []Lockable{}) fatalErr(t, err) _, err = UpdateStates(ctx, []GraphNode{r2}, func(states []NodeState) ([]NodeState, interface{}, error) { @@ -167,10 +167,10 @@ func TestLockableLockOther(t * testing.T) { func TestLockableLockSimpleConflict(t * testing.T) { ctx := testContext(t) - r1, err := NewLockable(ctx, "Test lockable 1", []Lockable{}) + r1, err := NewBaseLockable(ctx, "Test lockable 1", []Lockable{}) fatalErr(t, err) - r2, err := NewLockable(ctx, "Test lockable 2", []Lockable{}) + r2, err := NewBaseLockable(ctx, "Test lockable 2", []Lockable{}) fatalErr(t, err) err = LockLockable(ctx, r1, r1, nil) @@ -215,13 +215,13 @@ func TestLockableLockSimpleConflict(t * testing.T) { func TestLockableLockTieredConflict(t * testing.T) { ctx := testContext(t) - r1, err := NewLockable(ctx, "Test lockable 1", []Lockable{}) + r1, err := NewBaseLockable(ctx, "Test lockable 1", []Lockable{}) fatalErr(t, err) - r2, err := NewLockable(ctx, "Test lockable 2", []Lockable{r1}) + r2, err := NewBaseLockable(ctx, "Test lockable 2", []Lockable{r1}) fatalErr(t, err) - r3, err := NewLockable(ctx, "Test lockable 3", []Lockable{r1}) + r3, err := NewBaseLockable(ctx, "Test lockable 3", []Lockable{r1}) fatalErr(t, err) err = LockLockable(ctx, r2, r2, nil) @@ -236,7 +236,7 @@ func TestLockableLockTieredConflict(t * testing.T) { func TestLockableSimpleUpdate(t * testing.T) { ctx := testContext(t) - l1, err := NewLockable(ctx, "Test Lockable 1", []Lockable{}) + l1, err := NewBaseLockable(ctx, "Test Lockable 1", []Lockable{}) fatalErr(t, err) update_channel := l1.UpdateChannel(0) @@ -251,13 +251,13 @@ func TestLockableSimpleUpdate(t * testing.T) { func TestLockableDownUpdate(t * testing.T) { ctx := testContext(t) - l1, err := NewLockable(ctx, "Test Lockable 1", []Lockable{}) + l1, err := NewBaseLockable(ctx, "Test Lockable 1", []Lockable{}) fatalErr(t, err) - l2, err := NewLockable(ctx, "Test Lockable 2", []Lockable{l1}) + l2, err := NewBaseLockable(ctx, "Test Lockable 2", []Lockable{l1}) fatalErr(t, err) - _, err = NewLockable(ctx, "Test Lockable 3", []Lockable{l2}) + _, err = NewBaseLockable(ctx, "Test Lockable 3", []Lockable{l2}) fatalErr(t, err) update_channel := l1.UpdateChannel(0) @@ -272,13 +272,13 @@ func TestLockableDownUpdate(t * testing.T) { func TestLockableUpUpdate(t * testing.T) { ctx := testContext(t) - l1, err := NewLockable(ctx, "Test Lockable 1", []Lockable{}) + l1, err := NewBaseLockable(ctx, "Test Lockable 1", []Lockable{}) fatalErr(t, err) - l2, err := NewLockable(ctx, "Test Lockable 2", []Lockable{l1}) + l2, err := NewBaseLockable(ctx, "Test Lockable 2", []Lockable{l1}) fatalErr(t, err) - l3, err := NewLockable(ctx, "Test Lockable 3", []Lockable{l2}) + l3, err := NewBaseLockable(ctx, "Test Lockable 3", []Lockable{l2}) fatalErr(t, err) update_channel := l3.UpdateChannel(0) @@ -293,10 +293,10 @@ func TestLockableUpUpdate(t * testing.T) { func TestOwnerNotUpdatedTwice(t * testing.T) { ctx := testContext(t) - l1, err := NewLockable(ctx, "Test Lockable 1", []Lockable{}) + l1, err := NewBaseLockable(ctx, "Test Lockable 1", []Lockable{}) fatalErr(t, err) - l2, err := NewLockable(ctx, "Test Lockable 2", []Lockable{l1}) + l2, err := NewBaseLockable(ctx, "Test Lockable 2", []Lockable{l1}) fatalErr(t, err) update_channel := l2.UpdateChannel(0) diff --git a/thread_test.go b/thread_test.go index 1f97bb9..ff23a77 100644 --- a/thread_test.go +++ b/thread_test.go @@ -34,7 +34,7 @@ func TestNewEvent(t * testing.T) { func TestEventWithRequirement(t * testing.T) { ctx := logTestContext(t, []string{"lockable", "thread"}) - l1, err := NewLockable(ctx, "Test Lockable 1", []Lockable{}) + l1, err := NewBaseLockable(ctx, "Test Lockable 1", []Lockable{}) fatalErr(t, err) t1, err := NewSimpleBaseThread(ctx, "Test Thread 1", []Lockable{l1}, ThreadActions{}, ThreadHandlers{})