)
    if response.status_code != 200:
        logging.error(f"Response was not 200, after: {after}")
        logging.error(response.text)
        raise RuntimeError(response.text)
    data = response.json()
    if "errors" in data:
        logging.error(f"Errors in response, after: {after}")
        logging.error(data["errors"])
        logging.error(response.text)

		t.Fatalf("Blog should has three tags after Append")
	}

	if DB.Model(&blog).Association("SharedTags").Count() != 3 {
		t.Fatalf("Blog should has three tags after Append")
	}

	if DB.Model(&blog2).Association("SharedTags").Count() != 3 {
		t.Fatalf("Blog should has three tags after Append")
	}

	var tags []Tag
	DB.Model(&blog).Association("SharedTags").Find(&tags)

                                    after(VALIDATE),
                                    phase(SOURCES),
                                    phase(RESOURCES),
                                    phase(COMPILE, after(SOURCES), dependencies(SCOPE_COMPILE, READY)),
                                    phase(READY, after(COMPILE), after(RESOURCES)),
                                    phase(PACKAGE, after(READY), dependencies(SCOPE_RUNTIME, PACKAGE))),

    CountingRunnable after = new CountingRunnable();

    future.addListener(before, directExecutor());
    future.setFuture(delegate);
    future.addListener(inBetween, directExecutor());
    delegate.set(1);
    future.addListener(after, directExecutor());

    before.assertRun();
    inBetween.assertRun();
    after.assertRun();
  }

		t.Fatalf("Error happened when delete pet, got %v", err)
	}
	AssertAssociationCount(t, user2, "Pets", 1, "after delete non-existing data")

	if err := DB.Model(&user2).Association("Pets").Delete(&pet2); err != nil {
		t.Fatalf("Error happened when delete Pets, got %v", err)
	}
	AssertAssociationCount(t, user2, "Pets", 0, "after delete")

	// Prepare Data for Clear

        // Test release (still in use because of initial transport acquire)
        session.release();
        assertTrue(session.isInUse(), "Session should still be in use after one release");

        // Test final release
        session.release();
        assertFalse(session.isInUse(), "Session should not be in use after all releases");

    for (int i = 0; i < ITERATIONS; i++) {
      long before = map.get(key);
      long result = map.addAndGet(key, addend);
      long after = map.get(key);
      assertEquals(before + addend, after);
      assertEquals(after, result);
      addend = after;
    }
    assertEquals(1, map.size());
    assertTrue(!map.isEmpty());
    assertTrue(map.containsKey(key));
  }

				}
			} else if idx := getRIndex(names, c.after); idx != -1 {
				// if after callback exists but haven't sorted
				// set after callback's before callback to current callback
				after := cs[idx]

				if after.before == "" {
					after.before = c.name
				}

				if err := sortCallback(after); err != nil {
					return err
				}

    for (int i = 0; i < ITERATIONS; i++) {
      long before = map.get(key);
      long result = map.addAndGet(key, addend);
      long after = map.get(key);
      assertEquals(before + addend, after);
      assertEquals(after, result);
      addend = after;
    }
    assertEquals(1, map.size());
    assertTrue(!map.isEmpty());
    assertTrue(map.containsKey(key));
  }

      "FINE: Q10000 scheduled after 100 µs: task",
      "FINE: Q10000 starting              : task",
      "FINE: Q10000 finished run in   0 µs: task",
      "FINE: Q10000 run again after  50 µs: task",
      "FINE: Q10000 starting              : task",
      "FINE: Q10000 finished run in   0 µs: task",
      "FINE: Q10000 run again after 150 µs: task",
      "FINE: Q10000 starting              : task",