The studies on the phenomena of fatigue in metals, and especially on the formation and growth rate of cracks have been conducted in 1972-1974 with continued intensity. Their results contribute to expanding our knowledge and give us a new insight into the sphere of metal fatigue which is a highly interdiscipline field. This makes the continuous amending and modifying of books on metal fatigue a necessity, unfortunately often related with the not easy task of changing one's opinions and critical analysis of established earlier notions. These aims were my chief concern when preparing the present edition of my book in which I made use of carefully selected new information from 1972-1973 and partly 1974 reports. This new matter has been included in many instances just to signal new facts or findings, since the limited space did not allow me to give them the amount of consideration they deserve. The book has been further supplemented with the results of micrographic studies conducted in co-operation with J. Kozubowski for which lowe him special thanks. I am also indebted to Mr. H. Mughrabi from Stuttgart for allowing me to publish in this book his very interesting micrographs of dislocation structures. Finally I should like to express my sincere thanks to Mr. E. Lepa for his concern in producing a good English translation of my book.
1 Fundamental concepts and fatigue processes.- 1.1 Fatigue stresses.- 1.2 Wohler fatigue diagrams.- 1.3 The low-cycle range.- 1.3.1 General testing methods. Fundamental formulae.- 1.3.2 The influence of various factors and testing conditions. Hardening and softening hypotheses.- 1.4 The stages in fatigue processes.- References.- 2 Fatigue phenomena.- 2.1 Introductory remarks.- 2.2 Slip bands.- 2.2.1 Slip bands in the region above the fatigue limit.- 2.2.2 Slip bands in the range below the fatigue limit.- 2.3 Extrusions and intrusions.- 2.3.1 Extrusions and intrusions in polycrystalline iron and copper.- 2.3.2 Models and hypotheses of extrusion and intrusion formation.- 2.4 Fatigue cracks.- 2.4.1 Crack sources and propagation.- 2.4.2 Microcracks in polycrystalline iron.- 2.5 Supplementary methods of studying fatigue phenomena.- 2.5.1 Fatigue phenomena and changes in physical properties.- 2.5.2 Ionic bombardment (etching) method.- 2.5.3 The thermal etching method.- 2.5.4 Fatigue phenomena and surface microroughness.- 2.6 A survey of studies on fatigue changes in different metals.- 2.6.1 Face-centered cubic metals and alloys.- 2.6.2 Body-centered cubic metals and alloys.- 2.6.3 Hexagonal close-packed metals.- 2.6.4 Microcracks initiation in electroplated steel samples.- 2.7 Theories of fatigue.- 2.7.1 General remarks and early theories.- 2.7.2 Dislocation theories and crack initiation models.- 2.7.3 Statistical theories.- 2.7.4 Energy theories.- References.- 3 Fatigue dislocation structures.- 3.1 Introduction.- 3.2 The dislocation structure in face-centered cubic metals and alloys.- 3.2.1 Copper and its alloys.- 3.2.2 Aluminium and aluminium alloys.- 3.2.3 Austenitic steels.- 3.2.4 Other metals and alloys.- 3.3 The dislocation structure in body-centered cubic metals and alloys.- 3.3.1 Iron and iron alloys.- 3.3.2 Non-ferrous metals and alloys.- 3.4 The dislocation structure in hexagonal close-packed metals and alloys.- 3.5 An attempt at a synthesis.- References.- 4 Fatigue crack growth.- 4.1 General remarks.- 4.2 Description of crack growth.- 4.3 Fundamental relations for determining the fatigue crack growth rate.- 4.4 The influence of loading conditions on fatigue crack propagation rates. Sundry problems (Examples).- 4.5 Non-propagating fatigue cracks.- References.- 5 Fatigue fractures.- 5.1 Introduction.- 5.2 Classification of fractures and their characteristic features.- 5.2.1 General classification of fractures.- 5.2.2 The fundamental types of fracture.- 5.3 The macrostructure of fatigue fractures.- 5.3.1 Specific features of fracture surfaces.- 5.3.2 The macrostructure of fractures and the loading mode (Examples).- 5.4 The microstructure of fatigue fractures.- 5.4.1 General remarks.- 5.4.2 Fatigue striations.- 5.4.3 Tire tracks.- 5.4.4 Examples of fracture microstructure and their interpretations.- 5.4.5 Concluding remarks.- References.


text:
namespace syncer {

namespace {

testing::AssertionResult ModelTypeSetEquals(ModelTypeSet a, ModelTypeSet b) {
  if (a == b) {
    return testing::AssertionSuccess();
  } else {
    return testing::AssertionFailure()
           << "Left side " << ModelTypeSetToString(a)
           << ", does not match rigth side: " << ModelTypeSetToString(b);
  }
}

}  // namespace

class NudgeTrackerTest : public ::testing::Test {
 public:
  NudgeTrackerTest() { SetInvalidationsInSync(); }

  static size_t GetHintBufferSize() {
    // Assumes that no test has adjusted this size.
    return NudgeTracker::kDefaultMaxPayloadsPerType;
  }

  bool InvalidationsOutOfSync() const {
    // We don't currently track invalidations out of sync on a per-type basis.
    sync_pb::GetUpdateTriggers gu_trigger;
    nudge_tracker_.FillProtoMessage(BOOKMARKS, &gu_trigger);
    return gu_trigger.invalidations_out_of_sync();
  }

  int ProtoLocallyModifiedCount(ModelType type) const {
    sync_pb::GetUpdateTriggers gu_trigger;
    nudge_tracker_.FillProtoMessage(type, &gu_trigger);
    return gu_trigger.local_modification_nudges();
  }

  int ProtoRefreshRequestedCount(ModelType type) const {
    sync_pb::GetUpdateTriggers gu_trigger;
    nudge_tracker_.FillProtoMessage(type, &gu_trigger);
    return gu_trigger.datatype_refresh_nudges();
  }

  void SetInvalidationsInSync() {
    nudge_tracker_.OnInvalidationsEnabled();
    nudge_tracker_.RecordSuccessfulSyncCycle({});
  }

  std::unique_ptr<InvalidationInterface> BuildInvalidation(
      int64_t version,
      const std::string& payload) {
    return MockInvalidation::Build(version, payload);
  }

  static std::unique_ptr<InvalidationInterface>
  BuildUnknownVersionInvalidation() {
    return MockInvalidation::BuildUnknownVersion();
  }

  bool IsTypeThrottled(ModelType type) {
    return nudge_tracker_.GetTypeBlockingMode(type) == WaitInterval::THROTTLED;
  }

  bool IsTypeBackedOff(ModelType type) {
    return nudge_tracker_.GetTypeBlockingMode(type) ==
           WaitInterval::EXPONENTIAL_BACKOFF;
  }

 protected:
  NudgeTracker nudge_tracker_;
};

// Exercise an empty NudgeTracker.
// Use with valgrind to detect uninitialized members.
TEST_F(NudgeTrackerTest, EmptyNudgeTracker) {
  // Now we're at the normal, "idle" state.
  EXPECT_FALSE(nudge_tracker_.IsSyncRequired(ProtocolTypes()));
  EXPECT_FALSE(nudge_tracker_.IsGetUpdatesRequired(ProtocolTypes()));
  EXPECT_EQ(sync_pb::SyncEnums::UNKNOWN_ORIGIN, nudge_tracker_.GetOrigin());

  sync_pb::GetUpdateTriggers gu_trigger;
  nudge_tracker_.FillProtoMessage(BOOKMARKS, &gu_trigger);

  EXPECT_EQ(sync_pb::SyncEnums::UNKNOWN_ORIGIN, nudge_tracker_.GetOrigin());
}

// Verify that nudges override each other based on a priority order.
// RETRY < all variants of GU_TRIGGER
TEST_F(NudgeTrackerTest, OriginPriorities) {
  // Start with a retry request.
  const base::TimeTicks t0 =
      base::TimeTicks() + base::TimeDelta::FromMicroseconds(1234);
  const base::TimeTicks t1 = t0 + base::TimeDelta::FromSeconds(10);
  nudge_tracker_.SetNextRetryTime(t0);
  nudge_tracker_.SetSyncCycleStartTime(t1);
  EXPECT_EQ(sync_pb::SyncEnums::RETRY, nudge_tracker_.GetOrigin());

  // Track a local nudge.
  nudge_tracker_.RecordLocalChange(ModelTypeSet(BOOKMARKS));
  EXPECT_EQ(sync_pb::SyncEnums::GU_TRIGGER, nudge_tracker_.GetOrigin());

  // A refresh request will override it.
  nudge_tracker_.RecordLocalRefreshRequest(ModelTypeSet(TYPED_URLS));
  EXPECT_EQ(sync_pb::SyncEnums::GU_TRIGGER, nudge_tracker_.GetOrigin());

  // Another local nudge will not be enough to change it.
  nudge_tracker_.RecordLocalChange(ModelTypeSet(BOOKMARKS));
  EXPECT_EQ(sync_pb::SyncEnums::GU_TRIGGER, nudge_tracker_.GetOrigin());

  // An invalidation will override the refresh request source.
  nudge_tracker_.RecordRemoteInvalidation(PREFERENCES,
                                          BuildInvalidation(1, "hint"));
  EXPECT_EQ(sync_pb::SyncEnums::GU_TRIGGER, nudge_tracker_.GetOrigin());

  // Neither local nudges nor refresh requests will override it.
  nudge_tracker_.RecordLocalChange(ModelTypeSet(BOOKMARKS));
  EXPECT_EQ(sync_pb::SyncEnums::GU_TRIGGER, nudge_tracker_.GetOrigin());
  nudge_tracker_.RecordLocalRefreshRequest(ModelTypeSet(TYPED_URLS));
  EXPECT_EQ(sync_pb::SyncEnums::GU_TRIGGER, nudge_tracker_.GetOrigin());
}

// Verifies the management of invalidation hints and GU trigger fields.
TEST_F(NudgeTrackerTest, HintCoalescing) {
  // Easy case: record one hint.
  {
    nudge_tracker_.RecordRemoteInvalidation(BOOKMARKS,
                                            BuildInvalidation(1, "bm_hint_1"));

    sync_pb::GetUpdateTriggers gu_trigger;
    nudge_tracker_.FillProtoMessage(BOOKMARKS, &gu_trigger);
    ASSERT_EQ(1, gu_trigger.notification_hint_size());
    EXPECT_EQ("bm_hint_1", gu_trigger.notification_hint(0));
    EXPECT_FALSE(gu_trigger.client_dropped_hints());
  }

  // Record a second hint for the same type.
  {
    nudge_tracker_.RecordRemoteInvalidation(BOOKMARKS,
                                            BuildInvalidation(2, "bm_hint_2"));

    sync_pb::GetUpdateTriggers gu_trigger;
    nudge_tracker_.FillProtoMessage(BOOKMARKS, &gu_trigger);
    ASSERT_EQ(2, gu_trigger.notification_hint_size());

    // Expect the most hint recent is last in the list.
    EXPECT_EQ("bm_hint_1", gu_trigger.notification_hint(0));
    EXPECT_EQ("bm_hint_2", gu_trigger.notification_hint(1));
    EXPECT_FALSE(gu_trigger.client_dropped_hints());
  }

  // Record a hint for a different type.
  {
    nudge_tracker_.RecordRemoteInvalidation(PASSWORDS,
                                            BuildInvalidation(1, "pw_hint_1"));

    // Re-verify the bookmarks to make sure they're unaffected.
    sync_pb::GetUpdateTriggers bm_gu_trigger;
    nudge_tracker_.FillProtoMessage(BOOKMARKS, &bm_gu_trigger);
    ASSERT_EQ(2, bm_gu_trigger.notification_hint_size());
    EXPECT_EQ("bm_hint_1", bm_gu_trigger.notification_hint(0));
    EXPECT_EQ("bm_hint_2",
              bm_gu_trigger.notification_hint(1));  // most recent last.
    EXPECT_FALSE(bm_gu_trigger.client_dropped_hints());

    // Verify the new type, too.
    sync_pb::GetUpdateTriggers pw_gu_trigger;
    nudge_tracker_.FillProtoMessage(PASSWORDS, &pw_gu_trigger);
    ASSERT_EQ(1, pw_gu_trigger.notification_hint_size());
    EXPECT_EQ("pw_hint_1", pw_gu_trigger.notification_hint(0));
    EXPECT_FALSE(pw_gu_trigger.client_dropped_hints());
  }
}

// Test the dropping of invalidation hints.  Receives invalidations one by one.
TEST_F(NudgeTrackerTest, DropHintsLocally_OneAtATime) {
  for (size_t i = 0; i < GetHintBufferSize(); ++i) {
    nudge_tracker_.RecordRemoteInvalidation(BOOKMARKS,
                                            BuildInvalidation(i, "hint"));
  }
  {
    sync_pb::GetUpdateTriggers gu_trigger;
    nudge_tracker_.FillProtoMessage(BOOKMARKS, &gu_trigger);
    EXPECT_EQ(GetHintBufferSize(),
              static_cast<size_t>(gu_trigger.notification_hint_size()));
    EXPECT_FALSE(gu_trigger.client_dropped_hints());
  }

  // Force an overflow.
  nudge_tracker_.RecordRemoteInvalidation(BOOKMARKS,
                                          BuildInvalidation(1000, "new_hint"));

  {
    sync_pb::GetUpdateTriggers gu_trigger;
    nudge_tracker_.FillProtoMessage(BOOKMARKS, &gu_trigger);
    EXPECT_TRUE(gu_trigger.client_dropped_hints());
    ASSERT_EQ(GetHintBufferSize(),
              static_cast<size_t>(gu_trigger.notification_hint_size()));

    // Verify the newest hint was not dropped and is the last in the list.
    EXPECT_EQ("new_hint",
              gu_trigger.notification_hint(GetHintBufferSize() - 1));

    // Verify the oldest hint, too.
    EXPECT_EQ("hint", gu_trigger.notification_hint(0));
  }
}

// Tests the receipt of 'unknown version' invalidations.
TEST_F(NudgeTrackerTest, DropHintsAtServer_Alone) {
  // Record the unknown version invalidation.
  nudge_tracker_.RecordRemoteInvalidation(BOOKMARKS,
                                          BuildUnknownVersionInvalidation());
  {
    sync_pb::GetUpdateTriggers gu_trigger;
    nudge_tracker_.FillProtoMessage(BOOKMARKS, &gu_trigger);
    EXPECT_TRUE(gu_trigger.server_dropped_hints());
    EXPECT_FALSE(gu_trigger.client_dropped_hints());
    ASSERT_EQ(0, gu_trigger.notification_hint_size());
  }

  // Clear status then verify.
  nudge_tracker_.RecordSuccessfulSyncCycle(ProtocolTypes());
  {
    sync_pb::GetUpdateTriggers gu_trigger;
    nudge_tracker_.FillProtoMessage(BOOKMARKS, &gu_trigger);
    EXPECT_FALSE(gu_trigger.client_dropped_hints());
    EXPECT_FALSE(gu_trigger.server_dropped_hints());
    ASSERT_EQ(0, gu_trigger.notification_hint_size());
  }
}

// Tests the receipt of 'unknown version' invalidations.  This test also
// includes a known version invalidation to mix things up a bit.
TEST_F(NudgeTrackerTest, DropHintsAtServer_WithOtherInvalidations) {
  // Record the two invalidations, one with unknown version, the other known.
  nudge_tracker_.RecordRemoteInvalidation(BOOKMARKS,
                                          BuildUnknownVersionInvalidation());
  nudge_tracker_.RecordRemoteInvalidation(BOOKMARKS,
                                          BuildInvalidation(10, "hint"));

  {
    sync_pb::GetUpdateTriggers gu_trigger;
    nudge_tracker_.FillProtoMessage(BOOKMARKS, &gu_trigger);
    EXPECT_TRUE(gu_trigger.server_dropped_hints());
    EXPECT_FALSE(gu_trigger.client_dropped_hints());
    ASSERT_EQ(1, gu_trigger.notification_hint_size());
    EXPECT_EQ("hint", gu_trigger.notification_hint(0));
  }

  // Clear status then verify.
  nudge_tracker_.RecordSuccessfulSyncCycle(ProtocolTypes());
  {
    sync_pb::GetUpdateTriggers gu_trigger;
    nudge_tracker_.FillProtoMessage(BOOKMARKS, &gu_trigger);
    EXPECT_FALSE(gu_trigger.client_dropped_hints());
    EXPECT_FALSE(gu_trigger.server_dropped_hints());
    ASSERT_EQ(0, gu_trigger.notification_hint_size());
  }
}

// Checks the behaviour of the invalidations-out-of-sync flag.
TEST_F(NudgeTrackerTest, EnableDisableInvalidations) {
  // Start with invalidations offline.
  nudge_tracker_.OnInvalidationsDisabled();
  EXPECT_TRUE(InvalidationsOutOfSync());
  EXPECT_TRUE(nudge_tracker_.IsGetUpdatesRequired(ProtocolTypes()));

  // Simply enabling invalidations does not bring us back into sync.
  nudge_tracker_.OnInvalidationsEnabled();
  EXPECT_TRUE(InvalidationsOutOfSync());
  EXPECT_TRUE(nudge_tracker_.IsGetUpdatesRequired(ProtocolTypes()));

  // We must successfully complete a sync cycle while invalidations are enabled
  // to be sure that we're in sync.
  nudge_tracker_.RecordSuccessfulSyncCycle(ProtocolTypes());
  EXPECT_FALSE(InvalidationsOutOfSync());
  EXPECT_FALSE(nudge_tracker_.IsGetUpdatesRequired(ProtocolTypes()));

  // If the invalidator malfunctions, we go become unsynced again.
  nudge_tracker_.OnInvalidationsDisabled();
  EXPECT_TRUE(InvalidationsOutOfSync());
  EXPECT_TRUE(nudge_tracker_.IsGetUpdatesRequired(ProtocolTypes()));

  // A sync cycle while invalidations are disabled won't reset the flag.
  nudge_tracker_.RecordSuccessfulSyncCycle(ProtocolTypes());
  EXPECT_TRUE(InvalidationsOutOfSync());
  EXPECT_TRUE(nudge_tracker_.IsGetUpdatesRequired(ProtocolTypes()));

  // Nor will the re-enabling of invalidations be sufficient, even now that
  // we've had a successful sync cycle.
  nudge_tracker_.RecordSuccessfulSyncCycle(ProtocolTypes());
  EXPECT_TRUE(InvalidationsOutOfSync());
  EXPECT_TRUE(nudge_tracker_.IsGetUpdatesRequired(ProtocolTypes()));
}

// Tests that locally modified types are correctly written out to the
// GetUpdateTriggers proto.
TEST_F(NudgeTrackerTest, WriteLocallyModifiedTypesToProto) {
  // Should not be locally modified by default.
  EXPECT_EQ(0, ProtoLocallyModifiedCount(PREFERENCES));

  // Record a local bookmark change.  Verify it was registered correctly.
  nudge_tracker_.RecordLocalChange(ModelTypeSet(PREFERENCES));
  EXPECT_EQ(1, ProtoLocallyModifiedCount(PREFERENCES));

  // Record a successful sync cycle.  Verify the count is cleared.
  nudge_tracker_.RecordSuccessfulSyncCycle(ProtocolTypes());
  EXPECT_EQ(0, ProtoLocallyModifiedCount(PREFERENCES));
}

// Tests that refresh requested types are correctly written out to the
// GetUpdateTriggers proto.
TEST_F(NudgeTrackerTest, WriteRefreshRequestedTypesToProto) {
  // There should be no refresh requested by default.
  EXPECT_EQ(0, ProtoRefreshRequestedCount(SESSIONS));

  // Record a local refresh request.  Verify it was registered correctly.
  nudge_tracker_.RecordLocalRefreshRequest(ModelTypeSet(SESSIONS));
  EXPECT_EQ(1, ProtoRefreshRequestedCount(SESSIONS));

  // Record a successful sync cycle.  Verify the count is cleared.
  nudge_tracker_.RecordSuccessfulSyncCycle(ProtocolTypes());
  EXPECT_EQ(0, ProtoRefreshRequestedCount(SESSIONS));
}

// Basic tests for the IsSyncRequired() flag.
TEST_F(NudgeTrackerTest, IsSyncRequired) {
  EXPECT_FALSE(nudge_tracker_.IsSyncRequired(ProtocolTypes()));

  // Initial sync request.
  nudge_tracker_.RecordInitialSyncRequired(BOOKMARKS);
  EXPECT_TRUE(nudge_tracker_.IsSyncRequired(ProtocolTypes()));
  // Note: The initial sync happens as part of a configuration cycle, not a
  // normal cycle, so here we need to use RecordInitialSyncDone() rather than
  // RecordSuccessfulSyncCycle().
  // A finished initial sync for a different data type doesn't affect us.
  nudge_tracker_.RecordInitialSyncDone({EXTENSIONS});
  EXPECT_TRUE(nudge_tracker_.IsSyncRequired(ProtocolTypes()));
  nudge_tracker_.RecordInitialSyncDone({BOOKMARKS});
  EXPECT_FALSE(nudge_tracker_.IsSyncRequired(ProtocolTypes()));

  // Sync request for resolve conflict.
  nudge_tracker_.RecordCommitConflict(BOOKMARKS);
  // Now a sync is required for BOOKMARKS.
  EXPECT_TRUE(nudge_tracker_.IsSyncRequired(ProtocolTypes()));
  EXPECT_TRUE(nudge_tracker_.IsSyncRequired({BOOKMARKS}));
  // But not for SESSIONS.
  EXPECT_FALSE(nudge_tracker_.IsSyncRequired({SESSIONS}));
  // A successful cycle for SESSIONS doesn't change anything.
  nudge_tracker_.RecordSuccessfulSyncCycle({SESSIONS});
  EXPECT_TRUE(nudge_tracker_.IsSyncRequired(ProtocolTypes()));
  // A successful cycle for all types resolves things.
  nudge_tracker_.RecordSuccessfulSyncCycle(ProtocolTypes());
  EXPECT_FALSE(nudge_tracker_.IsSyncRequired(ProtocolTypes()));

  // Local changes.
  nudge_tracker_.RecordLocalChange(ModelTypeSet(SESSIONS));
  EXPECT_TRUE(nudge_tracker_.IsSyncRequired(ProtocolTypes()));
  nudge_tracker_.RecordSuccessfulSyncCycle(ProtocolTypes());
  EXPECT_FALSE(nudge_tracker_.IsSyncRequired(ProtocolTypes()));

  // Refresh requests.
  nudge_tracker_.RecordLocalRefreshRequest(ModelTypeSet(SESSIONS));
  EXPECT_TRUE(nudge_tracker_.IsSyncRequired(ProtocolTypes()));
  nudge_tracker_.RecordSuccessfulSyncCycle(ProtocolTypes());
  EXPECT_FALSE(nudge_tracker_.IsSyncRequired(ProtocolTypes()));

  // Invalidations.
  nudge_tracker_.RecordRemoteInvalidation(PREFERENCES,
                                          BuildInvalidation(1, "hint"));
  EXPECT_TRUE(nudge_tracker_.IsSyncRequired(ProtocolTypes()));
  nudge_tracker_.RecordSuccessfulSyncCycle(ProtocolTypes());
  EXPECT_FALSE(nudge_tracker_.IsSyncRequired(ProtocolTypes()));
}

// Basic tests for the IsGetUpdatesRequired() flag.
TEST_F(NudgeTrackerTest, IsGetUpdatesRequired) {
  EXPECT_FALSE(nudge_tracker_.IsGetUpdatesRequired(ProtocolTypes()));

  // Initial sync request.
  // TODO(crbug.com/926184): This is probably wrong; a missing initial sync
  // should not cause IsGetUpdatesRequired(): The former happens during config
  // cycles, but the latter refers to normal cycles.
  nudge_tracker_.RecordInitialSyncRequired(BOOKMARKS);
  EXPECT_TRUE(nudge_tracker_.IsGetUpdatesRequired(ProtocolTypes()));
  nudge_tracker_.RecordInitialSyncDone(ProtocolTypes());
  EXPECT_FALSE(nudge_tracker_.IsGetUpdatesRequired(ProtocolTypes()));

  // Local changes.
  nudge_tracker_.RecordLocalChange(ModelTypeSet(SESSIONS));
  EXPECT_FALSE(nudge_tracker_.IsGetUpdatesRequired(ProtocolTypes()));
  nudge_tracker_.RecordSuccessfulSyncCycle(ProtocolTypes());
  EXPECT_FALSE(nudge_tracker_.IsGetUpdatesRequired(ProtocolTypes()));

  // Refresh requests.
  nudge_tracker_.RecordLocalRefreshRequest(ModelTypeSet(SESSIONS));
  EXPECT_TRUE(nudge_tracker_.IsGetUpdatesRequired(ProtocolTypes()));
  nudge_tracker_.RecordSuccessfulSyncCycle(ProtocolTypes());
  EXPECT_FALSE(nudge_tracker_.IsGetUpdatesRequired(ProtocolTypes()));

  // Invalidations.
  nudge_tracker_.RecordRemoteInvalidation(PREFERENCES,
                                          BuildInvalidation(1, "hint"));
  EXPECT_TRUE(nudge_tracker_.IsGetUpdatesRequired(ProtocolTypes()));
  nudge_tracker_.RecordSuccessfulSyncCycle(ProtocolTypes());
  EXPECT_FALSE(nudge_tracker_.IsGetUpdatesRequired(ProtocolTypes()));
}

// Test IsSyncRequired() responds correctly to data type throttling and backoff.
TEST_F(NudgeTrackerTest, IsSyncRequired_Throttling_Backoff) {
  const base::TimeTicks now = base::TimeTicks::Now();
  const base::TimeDelta throttle_length = base::TimeDelta::FromMinutes(0);

  EXPECT_FALSE(nudge_tracker_.IsSyncRequired(ProtocolTypes()));

  // A local change to sessions enables the flag.
  nudge_tracker_.RecordLocalChange(ModelTypeSet(SESSIONS));
  EXPECT_TRUE(nudge_tracker_.IsSyncRequired(ProtocolTypes()));

  // But the throttling of sessions unsets it.
  nudge_tracker_.SetTypesThrottledUntil(ModelTypeSet(SESSIONS), throttle_length,
                                        now);
  EXPECT_TRUE(IsTypeThrottled(SESSIONS));
  EXPECT_FALSE(nudge_tracker_.IsSyncRequired(ProtocolTypes()));

  // A refresh request for bookmarks means we have reason to sync again.
  nudge_tracker_.RecordLocalRefreshRequest(ModelTypeSet(BOOKMARKS));
  EXPECT_TRUE(nudge_tracker_.IsSyncRequired(ProtocolTypes()));

  // But the backoff of bookmarks unsets it.
  nudge_tracker_.SetTypeBackedOff(BOOKMARKS, throttle_length, now);
  EXPECT_TRUE(IsTypeThrottled(SESSIONS));
  EXPECT_TRUE(IsTypeBackedOff(BOOKMARKS));
  EXPECT_FALSE(nudge_tracker_.IsSyncRequired(ProtocolTypes()));

  // A refresh request for preferences means we have reason to sync again.
  nudge_tracker_.RecordLocalRefreshRequest(ModelTypeSet(PREFERENCES));
  EXPECT_TRUE(nudge_tracker_.IsSyncRequired(ProtocolTypes()));

  // A successful sync cycle means we took care of preferences.
  nudge_tracker_.RecordSuccessfulSyncCycle(ProtocolTypes());
  EXPECT_FALSE(nudge_tracker_.IsSyncRequired(ProtocolTypes()));

  // But we still haven't dealt with sessions and bookmarks. We'll need to
  // remember that sessions and bookmarks are out of sync and re-enable the flag
  // when their throttling and backoff interval expires.
  nudge_tracker_.UpdateTypeThrottlingAndBackoffState();
  EXPECT_FALSE(nudge_tracker_.IsTypeBlocked(SESSIONS));
  EXPECT_FALSE(nudge_tracker_.IsTypeBlocked(BOOKMARKS));
  EXPECT_TRUE(nudge_tracker_.IsSyncRequired(ProtocolTypes()));
}

// Test IsGetUpdatesRequired() responds correctly to data type throttling and
// backoff.
TEST_F(NudgeTrackerTest, IsGetUpdatesRequired_Throttling_Backoff) {
  const base::TimeTicks now = base::TimeTicks::Now();
  const base::TimeDelta throttle_length = base::TimeDelta::FromMinutes(0);

  EXPECT_FALSE(nudge_tracker_.IsGetUpdatesRequired(ProtocolTypes()));

  // A refresh request to sessions enables the flag.
  nudge_tracker_.RecordLocalRefreshRequest(ModelTypeSet(SESSIONS));
  EXPECT_TRUE(nudge_tracker_.IsGetUpdatesRequired(ProtocolTypes()));

  // But the throttling of sessions unsets it.
  nudge_tracker_.SetTypesThrottledUntil(ModelTypeSet(SESSIONS), throttle_length,
                                        now);
  EXPECT_FALSE(nudge_tracker_.IsGetUpdatesRequired(ProtocolTypes()));

  // A refresh request for bookmarks means we have reason to sync again.
  nudge_tracker_.RecordLocalRefreshRequest(ModelTypeSet(BOOKMARKS));
  EXPECT_TRUE(nudge_tracker_.IsGetUpdatesRequired(ProtocolTypes()));

  // But the backoff of bookmarks unsets it.
  nudge_tracker_.SetTypeBackedOff(BOOKMARKS, throttle_length, now);
  EXPECT_TRUE(IsTypeThrottled(SESSIONS));
  EXPECT_TRUE(IsTypeBackedOff(BOOKMARKS));
  EXPECT_FALSE(nudge_tracker_.IsGetUpdatesRequired(ProtocolTypes()));

  // A refresh request for preferences means we have reason to sync again.
  nudge_tracker_.RecordLocalRefreshRequest(ModelTypeSet(PREFERENCES));
  EXPECT_TRUE(nudge_tracker_.IsGetUpdatesRequired(ProtocolTypes()));

  // A successful sync cycle means we took care of preferences.
  nudge_tracker_.RecordSuccessfulSyncCycle(ProtocolTypes());
  EXPECT_FALSE(nudge_tracker_.IsGetUpdatesRequired(ProtocolTypes()));

  // But we still haven't dealt with sessions and bookmarks. We'll need to
  // remember that sessions and bookmarks are out of sync and re-enable the flag
  // when their throttling and backoff interval expires.
  nudge_tracker_.UpdateTypeThrottlingAndBackoffState();
  EXPECT_FALSE(nudge_tracker_.IsTypeBlocked(SESSIONS));
  EXPECT_FALSE(nudge_tracker_.IsTypeBlocked(BOOKMARKS));
  EXPECT_TRUE(nudge_tracker_.IsGetUpdatesRequired(ProtocolTypes()));
}

// Tests blocking-related getter functions when no types are blocked.
TEST_F(NudgeTrackerTest, NoTypesBlocked) {
  EXPECT_FALSE(nudge_tracker_.IsAnyTypeBlocked());
  EXPECT_FALSE(nudge_tracker_.IsTypeBlocked(SESSIONS));
  EXPECT_TRUE(nudge_tracker_.GetBlockedTypes().Empty());
}

// Tests throttling-related getter functions when some types are throttled.
TEST_F(NudgeTrackerTest, ThrottleAndUnthrottle) {
  const base::TimeTicks now = base::TimeTicks::Now();
  const base::TimeDelta throttle_length = base::TimeDelta::FromMinutes(0);

  nudge_tracker_.SetTypesThrottledUntil(ModelTypeSet(SESSIONS, PREFERENCES),
                                        throttle_length, now);

  EXPECT_TRUE(nudge_tracker_.IsAnyTypeBlocked());
  EXPECT_TRUE(IsTypeThrottled(SESSIONS));
  EXPECT_TRUE(IsTypeThrottled(PREFERENCES));
  EXPECT_FALSE(nudge_tracker_.GetBlockedTypes().Empty());
  EXPECT_EQ(throttle_length, nudge_tracker_.GetTimeUntilNextUnblock());

  nudge_tracker_.UpdateTypeThrottlingAndBackoffState();

  EXPECT_FALSE(nudge_tracker_.IsAnyTypeBlocked());
  EXPECT_FALSE(nudge_tracker_.IsTypeBlocked(SESSIONS));
  EXPECT_TRUE(nudge_tracker_.GetBlockedTypes().Empty());
}

// Tests backoff-related getter functions when some types are backed off.
TEST_F(NudgeTrackerTest, BackoffAndUnbackoff) {
  const base::TimeTicks now = base::TimeTicks::Now();
  const base::TimeDelta backoff_length = base::TimeDelta::FromMinutes(0);

  nudge_tracker_.SetTypeBackedOff(SESSIONS, backoff_length, now);
  nudge_tracker_.SetTypeBackedOff(PREFERENCES, backoff_length, now);

  EXPECT_TRUE(nudge_tracker_.IsAnyTypeBlocked());
  EXPECT_TRUE(IsTypeBackedOff(SESSIONS));
  EXPECT_TRUE(IsTypeBackedOff(PREFERENCES));
  EXPECT_FALSE(nudge_tracker_.GetBlockedTypes().Empty());
  EXPECT_EQ(backoff_length, nudge_tracker_.GetTimeUntilNextUnblock());

  nudge_tracker_.UpdateTypeThrottlingAndBackoffState();

  EXPECT_FALSE(nudge_tracker_.IsAnyTypeBlocked());
  EXPECT_FALSE(nudge_tracker_.IsTypeBlocked(SESSIONS));
  EXPECT_TRUE(nudge_tracker_.GetBlockedTypes().Empty());
}

TEST_F(NudgeTrackerTest, OverlappingThrottleIntervals) {
  const base::TimeTicks now = base::TimeTicks::Now();
  const base::TimeDelta throttle1_length = base::TimeDelta::FromMinutes(0);
  const base::TimeDelta throttle2_length = base::TimeDelta::FromMinutes(20);

  // Setup the longer of two intervals.
  nudge_tracker_.SetTypesThrottledUntil(ModelTypeSet(SESSIONS, PREFERENCES),
                                        throttle2_length, now);
  EXPECT_TRUE(ModelTypeSetEquals(ModelTypeSet(SESSIONS, PREFERENCES),
                                 nudge_tracker_.GetBlockedTypes()));
  EXPECT_TRUE(IsTypeThrottled(SESSIONS));
  EXPECT_TRUE(IsTypeThrottled(PREFERENCES));
  EXPECT_GE(throttle2_length, nudge_tracker_.GetTimeUntilNextUnblock());

  // Setup the shorter interval.
  nudge_tracker_.SetTypesThrottledUntil(ModelTypeSet(SESSIONS, BOOKMARKS),
                                        throttle1_length, now);
  EXPECT_TRUE(ModelTypeSetEquals(ModelTypeSet(SESSIONS, PREFERENCES, BOOKMARKS),
                                 nudge_tracker_.GetBlockedTypes()));
  EXPECT_TRUE(IsTypeThrottled(SESSIONS));
  EXPECT_TRUE(IsTypeThrottled(PREFERENCES));
  EXPECT_TRUE(IsTypeThrottled(BOOKMARKS));
  EXPECT_GE(throttle1_length, nudge_tracker_.GetTimeUntilNextUnblock());

  // Expire the first interval.
  nudge_tracker_.UpdateTypeThrottlingAndBackoffState();

  // SESSIONS appeared in both intervals.  We expect it will be throttled for
  // the longer of the two, so it's still throttled at time t1.
  EXPECT_TRUE(ModelTypeSetEquals(ModelTypeSet(SESSIONS, PREFERENCES),
                                 nudge_tracker_.GetBlockedTypes()));
  EXPECT_TRUE(IsTypeThrottled(SESSIONS));
  EXPECT_TRUE(IsTypeThrottled(PREFERENCES));
  EXPECT_FALSE(IsTypeThrottled(BOOKMARKS));
  EXPECT_GE(throttle2_length - throttle1_length,
            nudge_tracker_.GetTimeUntilNextUnblock());
}

TEST_F(NudgeTrackerTest, OverlappingBackoffIntervals) {
  const base::TimeTicks now = base::TimeTicks::Now();
  const base::TimeDelta backoff1_length = base::TimeDelta::FromMinutes(0);
  const base::TimeDelta backoff2_length = base::TimeDelta::FromMinutes(20);

  // Setup the longer of two intervals.
  nudge_tracker_.SetTypeBackedOff(SESSIONS, backoff2_length, now);
  nudge_tracker_.SetTypeBackedOff(PREFERENCES, backoff2_length, now);
  EXPECT_TRUE(ModelTypeSetEquals(ModelTypeSet(SESSIONS, PREFERENCES),
                                 nudge_tracker_.GetBlockedTypes()));
  EXPECT_TRUE(IsTypeBackedOff(SESSIONS));
  EXPECT_TRUE(IsTypeBackedOff(PREFERENCES));
  EXPECT_GE(backoff2_length, nudge_tracker_.GetTimeUntilNextUnblock());

  // Setup the shorter interval.
  nudge_tracker_.SetTypeBackedOff(SESSIONS, backoff1_length, now);
  nudge_tracker_.SetTypeBackedOff(BOOKMARKS, backoff1_length, now);
  EXPECT_TRUE(ModelTypeSetEquals(ModelTypeSet(SESSIONS, PREFERENCES, BOOKMARKS),
                                 nudge_tracker_.GetBlockedTypes()));
  EXPECT_TRUE(IsTypeBackedOff(SESSIONS));
  EXPECT_TRUE(IsTypeBackedOff(PREFERENCES));
  EXPECT_TRUE(IsTypeBackedOff(BOOKMARKS));
  EXPECT_GE(backoff1_length, nudge_tracker_.GetTimeUntilNextUnblock());

  // Expire the first interval.
  nudge_tracker_.UpdateTypeThrottlingAndBackoffState();

  // SESSIONS appeared in both intervals.  We expect it will be backed off for
  // the longer of the two, so it's still backed off at time t1.
  EXPECT_TRUE(ModelTypeSetEquals(ModelTypeSet(SESSIONS, PREFERENCES),
                                 nudge_tracker_.GetBlockedTypes()));
  EXPECT_TRUE(IsTypeBackedOff(SESSIONS));
  EXPECT_TRUE(IsTypeBackedOff(PREFERENCES));
  EXPECT_FALSE(IsTypeBackedOff(BOOKMARKS));
  EXPECT_GE(backoff2_length - backoff1_length,
            nudge_tracker_.GetTimeUntilNextUnblock());
}

TEST_F(NudgeTrackerTest, Retry) {
  const base::TimeTicks t0 = base::TimeTicks::FromInternalValue(12345);
  const base::TimeTicks t3 = t0 + base::TimeDelta::FromSeconds(3);
  const base::TimeTicks t4 = t0 + base::TimeDelta::FromSeconds(4);

  // Set retry for t3.
  nudge_tracker_.SetNextRetryTime(t3);

  // Not due yet at t0.
  nudge_tracker_.SetSyncCycleStartTime(t0);
  EXPECT_FALSE(nudge_tracker_.IsRetryRequired());
  EXPECT_FALSE(nudge_tracker_.IsGetUpdatesRequired(ProtocolTypes()));

  // Successful sync cycle at t0 changes nothing.
  nudge_tracker_.RecordSuccessfulSyncCycle(ProtocolTypes());
  EXPECT_FALSE(nudge_tracker_.IsRetryRequired());
  EXPECT_FALSE(nudge_tracker_.IsGetUpdatesRequired(ProtocolTypes()));

  // At t4, the retry becomes due.
  nudge_tracker_.SetSyncCycleStartTime(t4);
  EXPECT_TRUE(nudge_tracker_.IsRetryRequired());
  EXPECT_TRUE(nudge_tracker_.IsGetUpdatesRequired(ProtocolTypes()));

  // A sync cycle unsets the flag.
  nudge_tracker_.RecordSuccessfulSyncCycle(ProtocolTypes());
  EXPECT_FALSE(nudge_tracker_.IsRetryRequired());

  // It's still unset at the start of the next sync cycle.
  nudge_tracker_.SetSyncCycleStartTime(t4);
  EXPECT_FALSE(nudge_tracker_.IsRetryRequired());
}

// Test a mid-cycle update when IsRetryRequired() was true before the cycle
// began.
TEST_F(NudgeTrackerTest, IsRetryRequired_MidCycleUpdate1) {
  const base::TimeTicks t0 = base::TimeTicks::FromInternalValue(12345);
  const base::TimeTicks t1 = t0 + base::TimeDelta::FromSeconds(1);
  const base::TimeTicks t2 = t0 + base::TimeDelta::FromSeconds(2);
  const base::TimeTicks t5 = t0 + base::TimeDelta::FromSeconds(5);
  const base::TimeTicks t6 = t0 + base::TimeDelta::FromSeconds(6);

  nudge_tracker_.SetNextRetryTime(t0);
  nudge_tracker_.SetSyncCycleStartTime(t1);

  EXPECT_TRUE(nudge_tracker_.IsRetryRequired());

  // Pretend that we were updated mid-cycle.  SetSyncCycleStartTime is
  // called only at the start of the sync cycle, so don't call it here.
  // The update should have no effect on IsRetryRequired().
  nudge_tracker_.SetNextRetryTime(t5);

  EXPECT_TRUE(nudge_tracker_.IsRetryRequired());

  // Verify that the successful sync cycle clears the flag.
  nudge_tracker_.RecordSuccessfulSyncCycle(ProtocolTypes());
  EXPECT_FALSE(nudge_tracker_.IsRetryRequired());

  // Verify expecations around the new retry time.
  nudge_tracker_.SetSyncCycleStartTime(t2);
  EXPECT_FALSE(nudge_tracker_.IsRetryRequired());

  nudge_tracker_.SetSyncCycleStartTime(t6);
  EXPECT_TRUE(nudge_tracker_.IsRetryRequired());
}

// Test a mid-cycle update when IsRetryRequired() was false before the cycle
// began.
TEST_F(NudgeTrackerTest, IsRetryRequired_MidCycleUpdate2) {
  const base::TimeTicks t0 = base::TimeTicks::FromInternalValue(12345);
  const base::TimeTicks t1 = t0 + base::TimeDelta::FromSeconds(1);
  const base::TimeTicks t3 = t0 + base::TimeDelta::FromSeconds(3);
  const base::TimeTicks t5 = t0 + base::TimeDelta::FromSeconds(5);
  const base::TimeTicks t6 = t0 + base::TimeDelta::FromSeconds(6);

  // Schedule a future retry, and a nudge unrelated to it.
  nudge_tracker_.RecordLocalChange(ModelTypeSet(BOOKMARKS));
  nudge_tracker_.SetNextRetryTime(t1);
  nudge_tracker_.SetSyncCycleStartTime(t0);
  EXPECT_FALSE(nudge_tracker_.IsRetryRequired());

  // Pretend this happened in mid-cycle.  This should have no effect on
  // IsRetryRequired().
  nudge_tracker_.SetNextRetryTime(t5);
  EXPECT_FALSE(nudge_tracker_.IsRetryRequired());

  // The cycle succeeded.
  nudge_tracker_.RecordSuccessfulSyncCycle(ProtocolTypes());

  // The time t3 is greater than the GU retry time scheduled at the beginning of
  // the test, but later than the retry time that overwrote it during the
  // pretend 'sync cycle'.
  nudge_tracker_.SetSyncCycleStartTime(t3);
  EXPECT_FALSE(nudge_tracker_.IsRetryRequired());

  // Finally, the retry established during the sync cycle becomes due.
  nudge_tracker_.SetSyncCycleStartTime(t6);
  EXPECT_TRUE(nudge_tracker_.IsRetryRequired());
}

// Simulate the case where a sync cycle fails.
TEST_F(NudgeTrackerTest, IsRetryRequired_FailedCycle) {
  const base::TimeTicks t0 = base::TimeTicks::FromInternalValue(12345);
  const base::TimeTicks t1 = t0 + base::TimeDelta::FromSeconds(1);
  const base::TimeTicks t2 = t0 + base::TimeDelta::FromSeconds(2);

  nudge_tracker_.SetNextRetryTime(t0);
  nudge_tracker_.SetSyncCycleStartTime(t1);
  EXPECT_TRUE(nudge_tracker_.IsRetryRequired());

  // The nudge tracker receives no notifications for a failed sync cycle.
  // Pretend one happened here.
  EXPECT_TRUE(nudge_tracker_.IsRetryRequired());

  // Think of this as the retry cycle.
  nudge_tracker_.SetSyncCycleStartTime(t2);
  EXPECT_TRUE(nudge_tracker_.IsRetryRequired());

  // The second cycle is a success.
  nudge_tracker_.RecordSuccessfulSyncCycle(ProtocolTypes());
  EXPECT_FALSE(nudge_tracker_.IsRetryRequired());
}

// Simulate a partially failed sync cycle.  The callback to update the GU retry
// was invoked, but the sync cycle did not complete successfully.
TEST_F(NudgeTrackerTest, IsRetryRequired_FailedCycleIncludesUpdate) {
  const base::TimeTicks t0 = base::TimeTicks::FromInternalValue(12345);
  const base::TimeTicks t1 = t0 + base::TimeDelta::FromSeconds(1);
  const base::TimeTicks t3 = t0 + base::TimeDelta::FromSeconds(3);
  const base::TimeTicks t4 = t0 + base::TimeDelta::FromSeconds(4);
  const base::TimeTicks t5 = t0 + base::TimeDelta::FromSeconds(5);
  const base::TimeTicks t6 = t0 + base::TimeDelta::FromSeconds(6);

  nudge_tracker_.SetNextRetryTime(t0);
  nudge_tracker_.SetSyncCycleStartTime(t1);
  EXPECT_TRUE(nudge_tracker_.IsRetryRequired());

  // The cycle is in progress.  A new GU Retry time is received.
  // The flag is not because this cycle is still in progress.
  nudge_tracker_.SetNextRetryTime(t5);
  EXPECT_TRUE(nudge_tracker_.IsRetryRequired());

  // The nudge tracker receives no notifications for a failed sync cycle.
  // Pretend the cycle failed here.

  // The next sync cycle starts.  The new GU time has not taken effect by this
  // time, but the NudgeTracker hasn't forgotten that we have not yet serviced
  // the retry from the previous cycle.
  nudge_tracker_.SetSyncCycleStartTime(t3);
  EXPECT_TRUE(nudge_tracker_.IsRetryRequired());

  // It succeeds.  The retry time is not updated, so it should remain at t5.
  nudge_tracker_.RecordSuccessfulSyncCycle(ProtocolTypes());

  // Another sync cycle.  This one is still before the scheduled retry.  It does
  // not change the scheduled retry time.
  nudge_tracker_.SetSyncCycleStartTime(t4);
  EXPECT_FALSE(nudge_tracker_.IsRetryRequired());
  nudge_tracker_.RecordSuccessfulSyncCycle(ProtocolTypes());

  // The retry scheduled way back during the first cycle of this test finally
  // becomes due.  Perform a successful sync cycle to service it.
  nudge_tracker_.SetSyncCycleStartTime(t6);
  EXPECT_TRUE(nudge_tracker_.IsRetryRequired());
  nudge_tracker_.RecordSuccessfulSyncCycle(ProtocolTypes());
}

// Test the default nudge delays for various types.
TEST_F(NudgeTrackerTest, NudgeDelayTest) {
  // Set to a known value to compare against.
  nudge_tracker_.SetDefaultNudgeDelay(base::TimeDelta());

  // Bookmarks and preference both have "slow nudge" delays.
  EXPECT_EQ(nudge_tracker_.RecordLocalChange(ModelTypeSet(BOOKMARKS)),
            nudge_tracker_.RecordLocalChange(ModelTypeSet(PREFERENCES)));

  // Typed URLs has a default delay.
  EXPECT_EQ(nudge_tracker_.RecordLocalChange(ModelTypeSet(TYPED_URLS)),
            base::TimeDelta());

  // "Slow nudge" delays are longer than the default.
  EXPECT_GT(nudge_tracker_.RecordLocalChange(ModelTypeSet(BOOKMARKS)),
            base::TimeDelta());

  // Sessions has a "slow nudge".
  EXPECT_EQ(nudge_tracker_.RecordLocalChange(ModelTypeSet(SESSIONS)),
            nudge_tracker_.RecordLocalChange(ModelTypeSet(BOOKMARKS)));

  // Autofill has the longer delay of all.
  EXPECT_GT(nudge_tracker_.RecordLocalChange(ModelTypeSet(AUTOFILL)),
            nudge_tracker_.RecordLocalChange(ModelTypeSet(SESSIONS)));

  // A nudge with no types takes the longest delay.
  EXPECT_EQ(nudge_tracker_.RecordLocalChange(ModelTypeSet(AUTOFILL)),
            nudge_tracker_.RecordLocalChange(ModelTypeSet()));

  // The actual nudge delay should be the shortest of the set.
  EXPECT_EQ(
      nudge_tracker_.RecordLocalChange(ModelTypeSet(TYPED_URLS)),
      nudge_tracker_.RecordLocalChange(ModelTypeSet(TYPED_URLS, AUTOFILL)));
}

// Test that custom nudge delays are used over the defaults.
TEST_F(NudgeTrackerTest, CustomDelayTest) {
  // Set some custom delays.
  std::map<ModelType, base::TimeDelta> delay_map;
  delay_map[BOOKMARKS] = base::TimeDelta::FromSeconds(10);
  delay_map[SESSIONS] = base::TimeDelta::FromSeconds(2);
  nudge_tracker_.OnReceivedCustomNudgeDelays(delay_map);

  // Only those with custom delays should be affected, not another type.
  EXPECT_NE(nudge_tracker_.RecordLocalChange(ModelTypeSet(BOOKMARKS)),
            nudge_tracker_.RecordLocalChange(ModelTypeSet(PREFERENCES)));

  EXPECT_EQ(base::TimeDelta::FromSeconds(10),
            nudge_tracker_.RecordLocalChange(ModelTypeSet(BOOKMARKS)));
  EXPECT_EQ(base::TimeDelta::FromSeconds(2),
            nudge_tracker_.RecordLocalChange(ModelTypeSet(SESSIONS)));
}

// Check that custom nudge delays can never result in a value shorter than the
// minimum nudge delay.
TEST_F(NudgeTrackerTest, NoTypesShorterThanDefault) {
  // Set delay to a known value.
  nudge_tracker_.SetDefaultNudgeDelay(base::TimeDelta::FromMilliseconds(500));

  std::map<ModelType, base::TimeDelta> delay_map;
  ModelTypeSet protocol_types = ProtocolTypes();
  // Add exception for low-latency data type.
  protocol_types.Remove(syncer::SHARING_MESSAGE);

  for (ModelType type : protocol_types) {
    delay_map[type] = base::TimeDelta();
  }
  nudge_tracker_.OnReceivedCustomNudgeDelays(delay_map);

  // All types should still have a nudge greater than or equal to the minimum.
  for (ModelType type : protocol_types) {
    EXPECT_GE(nudge_tracker_.RecordLocalChange(ModelTypeSet(type)),
              base::TimeDelta::FromMilliseconds(500));
  }
}

class NudgeTrackerAckTrackingTest : public NudgeTrackerTest {
 public:
  NudgeTrackerAckTrackingTest() {}

  bool IsInvalidationUnacknowledged(int tracking_id) {
    return tracker_.IsUnacked(tracking_id);
  }

  bool IsInvalidationAcknowledged(int tracking_id) {
    return tracker_.IsAcknowledged(tracking_id);
  }

  bool IsInvalidationDropped(int tracking_id) {
    return tracker_.IsDropped(tracking_id);
  }

  int SendInvalidation(ModelType type, int version, const std::string& hint) {
    // Build and register the invalidation.
    std::unique_ptr<TrackableMockInvalidation> inv =
        tracker_.IssueInvalidation(version, hint);
    int id = inv->GetTrackingId();

    // Send it to the NudgeTracker.
    nudge_tracker_.RecordRemoteInvalidation(type, std::move(inv));

    // Return its ID to the test framework for use in assertions.
    return id;
  }

  int SendUnknownVersionInvalidation(ModelType type) {
    // Build and register the invalidation.
    std::unique_ptr<TrackableMockInvalidation> inv =
        tracker_.IssueUnknownVersionInvalidation();
    int id = inv->GetTrackingId();

    // Send it to the NudgeTracker.
    nudge_tracker_.RecordRemoteInvalidation(type, std::move(inv));

    // Return its ID to the test framework for use in assertions.
    return id;
  }

  bool AllInvalidationsAccountedFor() const {
    return tracker_.AllInvalidationsAccountedFor();
  }

 private:
  MockInvalidationTracker tracker_;
};

// Test the acknowledgement of a single invalidation.
TEST_F(NudgeTrackerAckTrackingTest, SimpleAcknowledgement) {
  int inv_id = SendInvalidation(BOOKMARKS, 10, "hint");

  EXPECT_TRUE(IsInvalidationUnacknowledged(inv_id));

  nudge_tracker_.RecordSuccessfulSyncCycle(ProtocolTypes());
  EXPECT_TRUE(IsInvalidationAcknowledged(inv_id));

  EXPECT_TRUE(AllInvalidationsAccountedFor());
}

// Test the acknowledgement of many invalidations.
TEST_F(NudgeTrackerAckTrackingTest, ManyAcknowledgements) {
  int inv1_id = SendInvalidation(BOOKMARKS, 10, "hint");
  int inv2_id = SendInvalidation(BOOKMARKS, 14, "hint2");
  int inv3_id = SendInvalidation(PREFERENCES, 8, "hint3");

  EXPECT_TRUE(IsInvalidationUnacknowledged(inv1_id));
  EXPECT_TRUE(IsInvalidationUnacknowledged(inv2_id));
  EXPECT_TRUE(IsInvalidationUnacknowledged(inv3_id));

  nudge_tracker_.RecordSuccessfulSyncCycle(ProtocolTypes());
  EXPECT_TRUE(IsInvalidationAcknowledged(inv1_id));
  EXPECT_TRUE(IsInvalidationAcknowledged(inv2_id));
  EXPECT_TRUE(IsInvalidationAcknowledged(inv3_id));

  EXPECT_TRUE(AllInvalidationsAccountedFor());
}

// Test dropping when the buffer overflows and subsequent drop recovery.
TEST_F(NudgeTrackerAckTrackingTest, OverflowAndRecover) {
  std::vector<int> invalidation_ids;

  int inv10_id = SendInvalidation(BOOKMARKS, 10, "hint");
  for (size_t i = 1; i < GetHintBufferSize(); ++i) {
    invalidation_ids.push_back(SendInvalidation(BOOKMARKS, i + 10, "hint"));
  }

  for (int id : invalidation_ids)
    EXPECT_TRUE(IsInvalidationUnacknowledged(id));

  // This invalidation, though arriving the most recently, has the oldest
  // version number so it should be dropped first.
  int inv5_id = SendInvalidation(BOOKMARKS, 5, "old_hint");
  EXPECT_TRUE(IsInvalidationDropped(inv5_id));

  // This invalidation has a larger version number, so it will force a
  // previously delivered invalidation to be dropped.
  int inv100_id = SendInvalidation(BOOKMARKS, 100, "new_hint");
  EXPECT_TRUE(IsInvalidationDropped(inv10_id));

  // This should recover from the drop and bring us back into sync.
  nudge_tracker_.RecordSuccessfulSyncCycle(ProtocolTypes());

  for (int id : invalidation_ids)
    EXPECT_TRUE(IsInvalidationAcknowledged(id));

  EXPECT_TRUE(IsInvalidationAcknowledged(inv100_id));

  EXPECT_TRUE(AllInvalidationsAccountedFor());
}

// Test receipt of an unknown version invalidation from the server.
TEST_F(NudgeTrackerAckTrackingTest, UnknownVersionFromServer_Simple) {
  int inv_id = SendUnknownVersionInvalidation(BOOKMARKS);
  EXPECT_TRUE(IsInvalidationUnacknowledged(inv_id));
  nudge_tracker_.RecordSuccessfulSyncCycle(ProtocolTypes());
  EXPECT_TRUE(IsInvalidationAcknowledged(inv_id));
  EXPECT_TRUE(AllInvalidationsAccountedFor());
}

// Test receipt of multiple unknown version invalidations from the server.
TEST_F(NudgeTrackerAckTrackingTest, UnknownVersionFromServer_Complex) {
  int inv1_id = SendUnknownVersionInvalidation(BOOKMARKS);
  int inv2_id = SendInvalidation(BOOKMARKS, 10, "hint");
  int inv3_id = SendUnknownVersionInvalidation(BOOKMARKS);
  int inv4_id = SendUnknownVersionInvalidation(BOOKMARKS);
  int inv5_id = SendInvalidation(BOOKMARKS, 20, "hint2");

  // These invalidations have been overridden, so they got acked early.
  EXPECT_TRUE(IsInvalidationAcknowledged(inv1_id));
  EXPECT_TRUE(IsInvalidationAcknowledged(inv3_id));

  // These invalidations are still waiting to be used.
  EXPECT_TRUE(IsInvalidationUnacknowledged(inv2_id));
  EXPECT_TRUE(IsInvalidationUnacknowledged(inv4_id));
  EXPECT_TRUE(IsInvalidationUnacknowledged(inv5_id));

  // Finish the sync cycle and expect all remaining invalidations to be acked.
  nudge_tracker_.RecordSuccessfulSyncCycle(ProtocolTypes());
  EXPECT_TRUE(IsInvalidationAcknowledged(inv1_id));
  EXPECT_TRUE(IsInvalidationAcknowledged(inv2_id));
  EXPECT_TRUE(IsInvalidationAcknowledged(inv3_id));
  EXPECT_TRUE(IsInvalidationAcknowledged(inv4_id));
  EXPECT_TRUE(IsInvalidationAcknowledged(inv5_id));

  EXPECT_TRUE(AllInvalidationsAccountedFor());
}

}  // namespace syncer

redpajama_set_name: RedPajamaGithub


text:
Русская версия Sign in Search
About Us What's on Repertoire Artists & Staff Plan Your Visit Museum Shop Partners
Adolf Shapiro
Adolf Shapiro was born July 4, 1939 in Kharkov. In 1962 he graduated from the Kharkov State Kotlyarevsky University of Arts and continued his work with Maria Klebel's creative workshop.
In 1962-1992 was the head of the Riga Youth Theatre. This theatre is a unique structure of the former Soviet Union for its two independent casts from Latvia and Russia, and is the winner of numerous international competitions. Among the most important works: Ivanov and The Wood Demon by Anton Chekhov, City at Dawn by Alexei Arbuzov, The Forest by Alexander Ostrovsky, The Golden Horse by Janis Rainis, Peer Gynt by Henrik Ibsen, The Prince of Homburg by Heinrich Kleist, Fear and Misery of the Third Reich by Bertold Brecht, And tomorrow there was a war by Boris Vasilyev, The Democracy by Joseph Brodsky and other performances. For many years he worked in collaboration with a talented theater artist Mart Kitaev.
Adolf Shapiro taught at the Riga State Conservatory and prepared two acting and one directing classes.
He worked in various theaters in Estonia: Estonian Maly Theatre, Estonian Drama Theatre after Viktor Kingisepp, City Theatre in Pärnu, Tallinn City Theatre (Linnatheatre).
In Rome on the festival "Theatre on Screen" he won the Grand Prix and Gold Medal for the film The Waltz Invention after Vladimir Nabokov`s play.
By his art Adolf Shapiro gained international prestige, and in 1990 was elected the president of the International Association of Theatre for Children and Young People (ASSITEJ), and since 1994 he is the president of the Russian Center of ASSITEJ.
Since 1993 Adolf Shapiro works as an independent stage director and drama teacher. Carried out performances abroad: in Venezuela — The Government Inspector by Nikolai Gogol, Nicaragua —The Cherry Orchard by Anton Chekhov, USA — The Three Sisters by Anton Chekhov, Chekhov. Postskriptum, Poland —Danish History based on Hans Christian Andersen, Israel —The Threepenny Opera by Bertold Brecht, Last Love by Isaac Singer, France — An Actor's Work on Himself by Konstantin Stanislavski, Right You Are (If You Think So) by Luigi Pirandello, Brazil — Chekhov`s Space, Fathers and Sons by Ivan Turgenev, Greece — Rose by Michael Sherman, Old Times by Harold Pinter, China — Uncle Vanya by Anton Chekhov.
He has taught and lead workshops in the USA (Harvard University, Carnegie Mellon University, University of Indianapolis, The University of Chicago), Germany (Berlin, Bad Pyrmont, National Theatre Munich), Poland (Teatr Ochoty), Israel (Gesher Theatre, Yiddishpiel Theatre), France (École nationale supérieure des arts et techniques du théâtre Lyon) and Italy (bi-annual festival METHODIKA 2007).
Resides and works in Estonia. In 2003 Shapiro was elected an Honoured Doctor of the Department of Performing Arts of the Tallinn Theatre Academy and Fine Arts College in Viljandi.
Adolf Shapiro worked in various Russian theatres.
Cooperates with the theatres of Saint Petersburg. At the Tovstonogov Bolshoi Drama Theatre (BDT) he has created performances based on works of Russian classics (The Cherry Orchard by Anton Chekhov, 1993, and The Forest by Alexander Ostrovsky, 1999, the artist Eduard Kochergin). At the Leningrad Theater of Comedy — The Easy Money by Alexander Ostrovsky (1985), at the BryantsevYouth Theatre — King Lear by William Shakespeare and Dandelion Wine by Ray Bradbury.
In 1997, he participated in the joint work on the play The Seagull by Anton Chekhov in the International Michael Chekhov Workshop in Melekhovo with directors William Gaskill (England), Elmo Nuiganen (Estonia), Gytis Padegimas (Lithuania).
In Moscow, on the stage of the Moscow Art Theatre (MAT) Adolf Shapiro set The Cabal of Hypocrites by Mikhail Bulgakov (1988 and 2001), The Cherry Orchard by Anton Chekhov (2004), The Precipice by Ivan Goncharov (2010), Mephisto based on the Klaus Mann`s novel (2015, artist Maria Tregubova). At the Oleg Tabakov Theatre — Recent by Maxim Gorky (1995) and The Lower Depths by Maxim Gorky (2000); At the Vakhtangov Theatre — Kabanchik by Viktor Rozov, Dear Liar by Jerome Kilty (1994); at the Mayakovsky Theatre — In the Bar of a Tokyo hotel by Tennessee Williams (1995); in the Russian Academic Youth Theatre — The Princess of the Dream by Edmond Rostand (1997); at the "Et Cetera" Theatre — Fahrenheit 451 based on Ray Bradbury`s novel (2007); at the Maly Theatre — Children of the Sun by Maxim Gorky (2008, Grand Prix of the "Hit of the Season").
In 2010, his production of the opera Lucia di Lammermoor by G. Donizetti at the Stanislavski and Nemirovich-Danchenko Moscow Academic Music Theatre (conductor Volf Gorelik, artistic director Andris Frejbergs, costume designer Elena Stepanova) became the winner of the Golden Mask National Theatre Award. In 2013, he staged the operetta The Merry Widow (Die lustige Witwe) by Franz Lehar at the same theater (art director Alexander Shishkin).
Adolf Shapiro is a playwright whose works are staged both in Russia and abroad. He is the author of Entr'acte and The Curtain Falls (Friendship of Peoples magazine award).
Adolf Shapiro's achievements in theatre have brought him a lot national and international awards, including the State Prize of Latvia, the State Prize of the Russian Federation, the title of Honoured Artist of Latvia, the Order of Friendship of the Russian Federation, the Moscow Award, the Order "Pro Terra Mariana" Estonia, the Order of the "Three Stars" Latvia, the Stanislavski Award, the "Hit of the Season" Award. Adolf Shapiro is an honorary doctor of the Shanghai Theatre Academy, the winner of the Baltic House Theatre Festival Award and Golden Mask National Theatre Award.
General partner of the Bolshoi Theatre is Ingosstrakh Insurance Company
Privileged partner of the Bolshoi Theatre is GUM
Live relays
Young Artists Opera Program
Schedule of Performances
Guest Companies
at the Bolshoi
Bolshoi's Tours
Bolshoi Opera
Bolshoi Ballet
Bolshoi Orchestra
Building Tours
of Trustees
The Bolshoi Foundation
The State Academic Bolshoi Theatre of Russia
Press service: pr@bolshoi.ru
Ticket office: tel. +7 (495) 455-5555, sales@bolshoi.ru
Made in Art. Lebedev Studio

redpajama_set_name: RedPajamaCommonCrawl


You might be able to deduct some of your student loan interest, but it all depends. This guide will help you figure out how much you can legally write off.
Student loans and taxes can both take a sizeable chunk of your earnings, but fortunately, the government offers a special tax break to those paying back student loans to help reduce the strain. The catch is, you can only write off the amount you've paid in student loan interest throughout the year, and only if you meet certain criteria. I explain this in more detail below so you know exactly what to do when you file your taxes.
The student loan interest deduction allows you to write off up to $2,500 per year from your taxes in student loan interest payments. Because this is a tax deduction and not a credit, it reduces your taxable income instead of your tax bill. If you earned $40,000 this year and you qualify for the full $2,500 student loan interest deduction, you would subtract this amount from your $40,000, leaving you with $37,500 of taxable income. You can reduce this number even further if you qualify for additional tax deductions.
Depending on how much money you make and where the income tax brackets fall for the year, your student loan interest tax deduction could push you into a lower tax bracket where you'll lose a smaller percentage of your money to the government. Even if it doesn't change your tax bracket, it can still save you up to $625 on your taxes each year.
You paid student loan interest on a qualified student loan during the tax year.
You were legally obligated to pay the interest -- that is, the loan is in your or your spouse's name, if you're married. You cannot claim this deduction for a student loan in your child's name even if you were the one making the payments.
You file taxes as single, head of household, married filing jointly, or qualifying widow(er).
You and your spouse, if you're married, cannot be claimed as dependents on someone else's tax return.
Your modified adjusted gross income (MAGI) is less than $65,000 for single filers, heads of household, and qualifying widow(er)s or less than $135,000 for married couples filing jointly. Single filers, heads of household, and qualifying widow(er)s with a MAGI between $65,000 and $80,000 may qualify for a reduced credit, as may married couples filing jointly with a MAGI between $135,000 and $165,000.
Most of these requirements are relatively straightforward, but the last one may be confusing for those who aren't familiar with adjusted gross income (AGI) and modified adjusted gross income (MAGI).
Your AGI is all of the income you earned in a year, minus certain deductions, like tax-deferred retirement contributions, half of self-employment taxes, health savings account contributions, tuition and fees, and student loan interest. Your MAGI is your AGI with certain deductions added back in. So you add back your student loan interest, tuition and fee deduction, rental losses, self-employment taxes, and other deductions. The result is your MAGI.
If you're filing single, head of household, or qualifying widow(er) and your MAGI is below $65,000 for the 2018 tax year, you qualify for the full $2,500 student loan interest tax deduction, assuming you paid at least $2,500 in student loan interest throughout the year. If you paid less than this, then you would only be able to write off the amount you actually paid. The same goes for married couples filing jointly whose MAGI is under $135,000.
Subtract $65,000 (or $135,000 for married couples filing jointly) from your MAGI.
Divide this amount by $15,000 ($30,000 for married couples).
Multiply this amount by the total student loan interest you paid in throughout the year, or the maximum deduction of $2,500, whichever is less.
Subtract your result from Step 3 from the total amount you paid in student loan interest or $2,500, whichever is less.
The remainder is the amount you can write off on your taxes.
For example, if you're a single adult with a MAGI of $70,000, you would subtract $65,000 from this, leaving you with $5,000. You would divide this by $15,000, which comes out to one-third. Then, you multiply this by how much you paid in student loan interest. If you paid $2,500 or more, you end up with $833. Subtract this from the $2,500 and you end up with $1,667. This is how much you can claim for a student loan interest deduction.
Single filers, heads of household, and qualifying widow(er)s with a MAGI over $80,000 and married couples filing jointly with a MAGI over $165,000 aren't eligible for the student loan interest deduction.
If you paid more than $600 in student loan interest throughout the year, your lender is required to send you a 1098-E form, listing how much you paid in interest throughout the year. You'll find this number in Box 1. You can still write off the interest even if you didn't receive a 1098-E, but it's up to you to figure out how much you actually paid in interest. If you aren't sure, reach out to your lender directly to ask. Hold on to any records you have showing how much you paid in interest. If the government audits you, you'll need these to prove your deduction was legitimate.
You'll enter your total student loan interest deductions on Line 33 of your Form 1040. If you're using a tax filing software, it should prompt you to enter the amount you paid in student loan interest. It will also calculate the amount of the deduction you're entitled to if your MAGI is too high to qualify for the full student loan interest deduction. You don't have to itemize your deductions in order to claim the student loan interest tax deduction, though you can if you want.
If you run into any questions about deducting your student loan payments, it's best to consult with an accountant or your student loan servicer before filing your taxes. The wrong answer could lead you into trouble with the IRS.


Spotify breaks into the top of the music streaming apps in both Apple iTunes and Google Play. The popular streaming application now has 40 million users in 57 markets worldwide and 30 million songs on catalogue. Among all free and paid apps, Spotify is the only music app that made it to the top ten.
Spotify gives users an unbeatable music experience with its amazing audio streaming quality of up to 320kbps and its expansive OPM and global library with over 30 million songs. Spotify also makes music sharing more fun. With its amazing music discovery tool, users can check out what their Facebook friends and favorite singers are listening to, create playlists and share it to their followers.
Since Spotify's launch in the Philippines last April with exclusive telco partner Globe Telecom, customers were able to enjoy music streaming on mobile and tablets for free with a GoSURF data plan. To date, over 90% of Globe GoSURF customers use and listen to music on Spotify on their phones.
"Since we launched GoSURF and Spotify, we have received overwhelming feedback from customers as we provide them an enriching mobile experience with access to browsing and music content in one innovative offer," shares Globe VP for Mobile Data Services Jenny Echevarria.
All Globe customers registered to GoSURF get premium access to all the music they want free through Spotify, alongside access to the internet for sending e-mails, updating social networks, sharing photos or playing games. Streaming Spotify is completely free and won't eat up a GoSURF data plan's mobile internet allocation.
So whether you're a social media spectator –busy checking everyone else's status, posts, selfies, or a social media butterfly- constantly posting hilarious videos, quizzes for your friends to take, and responding to comments in a flash, GoSURF has the right data plan that fits your digital lifestyle. Stay online for as low as P10 for 10 MB of data valid for 1 day. If you want to stay online longer, you can register to GoSURF299 with 700MB of data for 30 days plus free Spotify Premium. Spotify Premium lets you listen to music without any advertisements, stream music with the highest quality audio and download music using offline mode so you can listen to songs even without an internet connection or WiFi!
Make your world sound wonderful with GoSURF and Spotify. Prepaid subscribers can register to GoSURF10 which gives 10MB of data and free access to Spotify for 1 day, while Postpaid subscribers can avail of GoSURF 299 with 700MB of data valid for 30 days plus free access to Spotify Premium.
Register by dialing *143# and choose GoSURF or texting GOSURF to 8888. To know more about GoSURF and Spotify, visit www.globe.com.ph/surf/plan/gosurf.


text:
Slobodan Prosperov Novak (Beograd, 11. travnja 1951.) je hrvatski povjesničar književnosti, komparatist, novinar, političar i teatrolog.

Životopis
Djetinjstvo provodi u Dubrovniku gdje je završio osnovnu školu i gimnaziju društvenoga smjera, te nižu muzičku školu. Književne tekstove počeo je objavljivati godine 1969. najprije u časopisima Dubrovnik, Naša riječ i Laus. Diplomirao je komparativnu književnost 1973. na Filozofskome fakultetu Sveučilišta u Zagrebu, na kojem je magistrirao 1976. i doktorirao 1978. godine. Radio je kao novinar Vjesnika u srijedu (1973. – 1974.). Godine 1977. postaje asistentom, zatim docentom te redovitim profesorom (1988.) na Katedri za stariju hrvatsku književnost Filozofskoga fakulteta u Zagrebu. U razdoblju od 1981. do 1984. predaje i u Institutu za slavensku filologiju Sveučilišta u Rimu, a od 1990. do 1992. pomoćnik je ministra prosvjete, kulture i športa Republike Hrvatske. Od 1990. do 1992. bio je predsjednikom Vijeća Dubrovačkih ljetnih igara, a 2000. i ravnateljem Igara.

Bio je pokretačem i glavnim urednikom novina Matice hrvatske Vijenca, časopisa "Lettre internationale" i magazina "Cicero". Niz godina uređivao je časopis hrvatskih književnika "Most/The Bridge" i istoimenu biblioteku. Bio je predsjednikom Hrvatskoga PEN-a (od 1990. do 2000.) pa je sa suradnicima 1993. u Dubrovniku organizirao 59. svjetski kongres PEN-a. Godine 1998. osnovao je Mediteranski institut Grga Novak na Hvaru. Od 2001. predaje južnoslavensku filologiju na odsjeku za slavistiku Sveučilišta Yale u New Havenu, SAD. Bio je profesorom hrvatske književnosti na Sveučilištu u Splitu i predavačem na tamošnjim odsjecima talijanistike i anglistike, a od 2010. do 2020. redoviti je profesor književnosti na Akademiji dramske umjetnosti Sveučilišta u Zagrebu.

Priredio je brojna izdanja hrvatskih pisaca, autor je niza sveučilišnih i školskih hrestomatija, a ostvario je i niz multimedijalnih projekata, među kojima su najvažnije kazališne predstave "Ecce homo" i "Kako bratja prodaše Jozefa" na Dubrovačkim ljetnim igrama 1985. i 1990., te velika izložba "Gundulićev san" 1989. u Muzejskom prostoru u Zagrebu. Drama "Mozartov sin" preporučena je teatrima za izvođenje na natječaju za dramu "Marin Držić" 2013.

Djela (izbor)
 Dubrovački eseji i zapisi, 1975.
 Teatar u Dubrovniku prije Marina Držića, 1977.
 Vučistrah i dubrovačka tragikomedija, 1979.
 Komparatističke zagonetke, 1979.
 Zašto se Euridika osvrnula, 1981.
 Planeta Držić, 1984.
 Dubrovnik iznova, 1987.
 Kad su đavli voljeli hrvatski, 1988.
 Hrvatski pluskvamperfekt, 1991.
 Figure straha, 1994.
 Povijest hrvatske književnosti (tri sveska), 1996., 1997., 1999.
 Kratka povijest avanturizma, 2001.
 Zlatno doba, 2002.
 Povijest hrvatske književnosti, (4 sveska), 2004.
 101 Dalmatinac i poneki Vlaj, 2005.
 Hrvatske renesanse tragedije, 2006.
 Hvar: mjesta, ljudi, sudbine, 2006.
 Predavanja iz hrvatske renesanse književnosti na Sveučilištu Yale, 2008.
 Leksikon Marina Držića, ur., 2009.
 Slaveni u renesansi, 2009.
 Pričaj mi o Europi, 2010.
 Zločesti tekstovi, 2011.
 101 Dalmatinka, 2010.
 Zločesti tekstovi, Profil, Zagreb, 2010.
 Boka kotorska od kampanela do kampanela, AGM, Zagreb, 2011.
 Knjiga o teatru, AGM, Zagreb,2014.
 Književnost ranog novovjekovlja u Boki kotorskoj., S Viktorijom Franić Tomić, Hrvatska sveučilišna naklada, Zagreb, 2014.
 Abrahamova žrtva, s Viktorijom Franić Tomić.Matica hrvatska, Zagreb, 2015.
 Split. Monografija., s Ivom Pervanom. Lilliput Planet, Zagreb, 2015.
 Marin Držić, Izabrana djela, I-II, Stoljeća hrvatske književnosti, Zagreb, 2011. – 2015.
 Zlatna knjiga bokeljskih književnika., s Viktorijom Franić Tomić, Lilliput Planet, Zagreb, 2016.
 Vruja. Grad vode i vjetra., Splićanka d. o. o., Split, 2016. (+ prijevod na engleski jezik i prijevod na ruski jezik)
 Pisac i vlast. Poetika Marina Držića, Školska knjiga, Zagreb, 2017.
 Kanonski korpus hrvatske književnosti, kulturne povijesti, filozofije i znanosti'', knjiški niz, 2019.

Ostalo
 "Velikani hrvatskog glumišta" kao sudionik dokuserijala (2018.)
 "Storije o neponovljivima" kao sudionik dokuserijala (2017.)
 "Libar Miljenka Smoje oli ča je život vengo fantažija" kao sudionik dokumentarnog serijala (2012.)

Izvori

Hrvatski književnici
Hrvatski književni povjesničari
Hrvatski teatrolozi
Hrvatski novinari
Hrvatski političari od 1989.

redpajama_set_name: RedPajamaWikipedia


text:
More Thoughts on Last Night
The fake punt is arguably the dumbest moment in sports history. Why? Even if Pat Mannelly thought there were twelve men on the field, the penalty only makes it 4th and 6. You're still punting. And I don't understand why he snaps it to Wolfe. The play starts on the snap. Send it to the damn punter. (Side note: why have coaches at all if the long snapper has the ability to do this? He's on the field 6 times a game!)
Jay Cutler and these receivers need to figure something out fast. Outside of the brilliant play by Jolly, the interceptions involved a quarterback and receiver moving in opposite directions. The Jackass route at the end of the game was pathetic. Fix it. Today.
Is everybody still worried about Devin Hester? Because I'm not.
Nathan Vasher didn't fail to cover Greg Jennings on the touchdown. Nathan Vasher CAN'T cover Greg Jennings. But while the world kills Vash's work on the play, I ask "where the hell was the safety?" Lovie can worship at the altar of the Cover 2 all he wants but what good is it if you've got Nathan Vasher man-to-man with an elite receiver with the game on the line?
If you've been following this club, the final two minutes were not surprising. What beat the Bears? Poor secondary play and inexperience at wide receiver.


text:
School Awakenings
It's Monday morning and recent history tells us that somewhere in the world kids are returning to school for the first time in weeks, or months. As the day gets underway, parents, students and teachers are trying to chart their way through a maelstrom of colliding emotions – excitement, anticipation, uncertainty and anxiety.
Martin Rowson – The Guardian
This morning, England is testing the waters. There had been some thought that this milestone would be a UK-wide kind of effort but neither Scotland, Wales, or Northern Ireland were keen to sign on. Numerous local education authorities in England have also decided to disregard the June date and are keeping schools closed. Results of an opinion poll published May 24 in The Guardian show only 50% of parents supported a June 1 resumption of classes.
As of May 25, UNESCO estimates that a staggering 1.2 billion learners worldwide continue to be out of school due to closures that are part of the public health and policy responses to the COVID-19 pandemic. Overarching lock down and shelter-in-place directives of varying severity have contributed to a massive, months long disruption of children's daily lives on a scale rarely experienced.
The impacts of closures go well beyond the realms of education and teaching time. Immunization programs, hosted by schools in some jurisdictions, are currently being interrupted. In lower and middle income countries this may have devastating consequences. Higher income countries could also find themselves at risk and are preparing for continuity as per Canada's plan.
Schools also play an important role in alleviating food insecurity. Breakfast and lunch programs promote healthy foods and nutritional meals. In lower and middle income countries these school food programs are critical to students' well-being. Research indicates that universal programs can result in significant, long term health and economic benefits. In some communities, such as Calgary, programs have been maintained throughout the pandemic and kids continue to benefit from healthy meals. However, this is not the case for many children.
On an education note, online/distance/emergency/home learning is meeting with mixed results for both parents and kids. At the primary level when it's working reasonably well, internet-based instruction is helping kids to keep sharp in key foundational areas like numeracy and literacy. However, not all children have access to the internet, or a computer. For them, keeping academically fresh is an uphill struggle.
But the school ethos is not exclusively about academics and curriculum, certainly not from the vantage point of the kids themselves. They miss the social setting, a gathering and growing place for peers, and perhaps most tellingly they long for the friendships that help define who they are and engender a sense of belonging. This absence of presence, the seemingly endless being apart, evokes loss and sorrow as represented by our youngest daughter's stripped down, open-ended refrain.
I just want to know
when will I ever get to play tag with my friends again?
In Sweden, kids have been playing with their friends all the while as schools were never shuttered. There have been some exceptions to this with localized closures for individual schools that experienced outbreaks. A lack of COVID-19 data collection from these schools is being decried by some in the scientific community as a missed window to better understanding how the virus impacts children and what role they may have in transmission. Overall the Swedish government approach to the pandemic has eschewed lock downs and other restrictions counting on citizens to do the right thing.
In mid-April, Danish kids are the first to break out of lock down as school bells signal the resumption of classes. Hygiene and distancing considerations are paramount as are creative solutions to space shortages (video).
Two key documents published by WHO and UNICEF – Considerations for school-related public health measures in the context of COVID-19 and Key Messages and Actions for COVID-19 Prevention and Control in Schools – are assisting administrators, teachers, parents, caregivers and students with the transition back to school.
Full or partial openings in other countries and jurisdictions followed the Danish lead. It's not the same old, same old as these photos from around the world capture a noticeably different look and feel. Kids in Australia, Austria, China, Denmark, France, Germany, Japan, New Zealand, Norway, Quebec, Taiwan, Vietnam and other venues are well on the way to developing routines that embrace a new normal. The most significant setback occurred last week in South Korea where more than 250 schools were closed.
As more children return to classrooms, governments need to broadly share best practices developed within their own jurisdictions. First and foremost, there must be an underlying commitment to follow the science. Also critical are key tools to build and maintain trust such as public engagement and outreach to parents. At a minimum, detailed plans – like this one from a British Columbia school district – documenting the return process should be made available to parents in advance of openings.
Consensus is coalescing around three priority areas that have the ability to give returning students a boost. PLAY, OUTDOOR LEARNING and RECESS are relatable for kids as they shift from home isolation to a rediscovery of peers in a school-based community. In the lead up to UK school openings, discussion around these themes has been very much in evidence.
Dr. Helen Dodd is a Professor of Child Psychology at the University of Reading. She is a charter member with other mental health experts of a newly formed ad hoc group, Play First UK which seeks to give greater voice to the needs and aspirations of children during the pandemic. We had an opportunity to speak last month.
Play First UK recommends that kids should be allowed to play with their peers as soon as possible as lock downs are loosened. These peer relationships are voluntary, equal and require negotiation and compromise. Research and observation show that play with peers allows children to learn to regulate their emotions, develop social skills and form a sense of identity. When this is not possible over extended periods kids can get lonely and feel socially isolated.
We're anticipating a huge increase for child psychology services
when we come out of this lock down period.
To offer kids a softer landing during school return transitions, Play First UK is advocating for more play. They have sent a series of recommendations to governments in Westminster, Edinburgh, Cardiff and Belfast and to the All Party Parliamentary Group for Children.
The easing of lock down restrictions should be done in a way that provides all children with the time and opportunity to play with peers, in and outside of school, and even while social distancing measures remain in place.
Schools should be appropriately resourced and given clear guidance on how to support children's emotional wellbeing during the transition period as schools reopen. Play should be a priority during this time, rather than academic progress.
Public health communications must recognise that many parents and teachers are anxious about their child's academic progress and the risk posed to children in easing lockdown restrictions. The social and emotional benefits of play and interaction with peers must be clearly communicated, alongside guidance on the objective risks to children.
Click through for full recommendations and letter.
From Dr. Dodd's perspective, we could all do with an empathy top up and remember that we're in uncharted territory.
"The kids will have to settle emotionally before we can really engage in teaching them. We're not saying to play all the time but to go easy on them – a bit more time with their peers, a bit more outdoor play and some more outdoor learning, a bit more physically active for a while and why not? All of this is good for kids anyway and will be positive experiences for most children."
Outdoor learning is generating some good conversation in the UK and is being put into practice in Scandinavia and other European countries. The UK, Scotland in particular, is developing some expertise in this area.
Juliet Roberston is a former Head Teacher in three different schools located in northern Scotland. She left the education system about a decade ago to dig more deeply into outdoor learning and play and is in demand by a number of local authorities and schools. You can find her @CreativeStar on Twitter. She is the author of Messy Maths – A Playful Outdoor Approach to Early Years. We spoke in May.
Think of the outdoors as additional rooms and
just like an indoor class develop routines around the space.
Robertson is among a group of practitioners who believe outdoor learning could play an important element in helping to maintain physical distancing. She also notes that just by being outside the probability of transmission is reduced. There are also mental health benefits associated with being outdoors that are present at any time but may prove helpful in a school re-entry transition.
Even though outdoor learning in Scotland has been a part of the curriculum since 2004, Robertson realizes there will still need to be reassurances for teaching staff. Fortunately, there is good infrastructure in place. Numerous resources and organizations focus on preparing teachers and leaders for outdoor learning. Keep your eyes open as good workshops are available like one I attended online a couple of weeks ago – Learning to Return Outdoors – Use of school grounds for curricular learning as schools tackle Covid-19 provided by Learning Through Landscapes.
Then there is recess, the only block of time in the school day to have garnered its own cartoon show. Definitely a favourite in our house no matter what time of year we poll the three kids. Now the Global Recess Alliance, "a newly formed group of scholars, health professionals, and education leaders, argues that attention to recess during school reopening is essential."
The Alliance's Statement on Recess has great practical advice that touches on rethinking school recess policies, safe recess practices and supporting a safe and healthy recess.
I particularly liked this safe recess practice –
"Recognize the importance of physically active play and consider a risk-benefit approach; strict rules like 'no running' and 'no ball throwing can undermine the benefits of play and physical activity."
As schools reopen, we can see it as an opportunity to request more time for play, more time in the outdoors and a don't mess with recess policy. From the top of this hill, the grass sure is looking greener on the other side
End note – our kids don't return to school until September. They were disappointed when they got the news. We were not. That's because we work from home and we're not adverse to a little more close-knit time together. We are very grateful for this and recognize that not everyone has the same flexibility. With the additional time, we are hoping that our kids' schools will be able to better prepare for openings and benefit from best practices pioneered in other jurisdictions.
A heartfelt thanks to our kids' teachers. They pulled the pieces together to enable the online learning experience to work for the students. They were there for the kids, connected with them and encouraged them to do their best.
A couple of weeks ago we 'bubbled' with our next door neighbours. They have one young lad. It was a wonderful boost to bring the two households together and see the incredible play impact it had and continues to have on what is now a merry band of four. We are hopefully anticipating the continued easing of restrictions.
There is a lot of great work underway as we live though these extreme times. These are just a few representative samples:
Covid-19 and children: what does the science tell us, and what does this mean as the lock down is eased? – Tim Gill – Rethinking Childhood
Reopening schools – how do we decide what's best? – Simon Weedy – Child in the City
Academics highlight children's need for street play during lockdown – Policy for Play
Learning to Return Outdoors – learning outdoors as schools return – Learning Through Landscapes
Posted in @CreativeStar, coronavirus, COVID-19, Dr. Helen Dodd, Global Recess Alliance, More Play, outdoor learning, Play FIrst UK, Recess, school closures, school openings, WHO
Scattered Sidewalk Beacons
In these unsettling days, acts of kindness and playfulness are doing their part to disperse the coronavirus pall. Around the world, gestures small and large are bringing smiles to faces, providing relief and helping with resolve.
Stories of kindness are being shared daily by news outlets as well as by family, social and professional networks. This story is from the community where we live, Eastern Passage, Nova Scotia.
Along the community's Shore Road, facing the eastern approaches at the head of Halifax's harbour, a series of sidewalk beacons are shining their lights. Small coloured stones and larger painted rocks are scattered on the coarse gravel between sidewalk and culvert along a half kilometre stretch.
The rock art and mini message boards are invisible to those whizzing by in cars but walkers, runners and cyclists pause to look, ponder, smile. Our daughters read every word, admired the artwork and selected their favourites. The short, simple messages resonated deeply. Hats off to the creators of this neighbourhood gallery for brightening up the day of all those who pass by.
Here is a selection of Shore Road's Scattered Sidewalk Beacons.
Thank you doctors and all the health care workers
Thank you all of the health professionals
Thank you to the artists and the wordsmiths. Our family was uplifted by this small strip of coastal wonder.
Posted in community action, coronavirus, Eastern Passage, health care professionals, kindness, Nova Scotia, playfulness
With a large map weighted at the corners spread out before her, our youngest is charting future adventures with an erasable marker. I have to get in quick for a photo before her first odyssey is wiped clear.
I visit every zoo in Canada and get those poor animals out of there. Go to all the spots the animals live that I saved and go to Amazon!!!!! Click to enlarge
A few years ago this was a recurring activity on a map affixed to her bedroom wall. It coincided with a head over heels embrace of Dora The Explorer. Oh the places our then 6-year-old would go!
This brand spanking new map had been tucked away in a closet waiting to be found on a proverbial rainy day. No better time for maman to break it out as we're well into the coronavirus deluge now – uncharted territory for families, neighbourhoods, communities and governments.
I can almost taste the resilience of this mapping play, imaginative, forward looking, new worlds creativity. The activity is a nimble pivot from news shared with the kids earlier in the afternoon – no longer would friends be allowed to come to our house to play indoors or outside in the yard.
7 years later from Amazon – find water animals help them if needed. Meet new friends and take them on my journey. Bring my Kids! And dogy
Our newly self-imposed isolation and social distancing followed a series of disruptions impacting primarily the kids – cancellations of spring basketball, Cubs and Scouts, cinemas, an overseas vacation and the big grandaddy of them all, school – the learning, playing and socializing space.
We are not alone of course. This is happening across vast areas of the globe. UNESCO estimates that on March 18 more than 861 million students in over 100 countries would be out of school for varying lengths of time. It seems that the world is grinding to a halt as the virus tries to overtake us.
Public health professionals and journalists are working zealously to inform citizens of important life saving actions that can help to curb the virus' spread. People still have so many questions and not all have a ready answer. Sometimes once you think you've got one, you hear a different response and have to assess which is most likely to be accurate.
Two days ago I couldn't find anything authoritative related to the risk associated with outdoor neighbourhood play. Should we have the kids out playing in a pandemic? One public health expert indicated that the risk would be low if the place in question was not experiencing community spread.
This was my doctrine for a day until I heard from a city councillor and then a design and build playground company, both from other parts of Canada. Their comments on PlayGroundology's Facebook page nudged our family into limiting outdoor play to the backyard with our kids only, no friends.
Backyard – just siblings, no friends
From there it was an almost effortless drift into significantly reducing our in-person social interactions at an earlier date than we might have otherwise considered. This may ease the transition to full self-isolation when public health authorities call for it. If you are weighing what action to take, you may find this piece from the BBC helpful, Coronavirus: Should you let your children play with other children?
Before we know it the maelstrom will be upon us here on Canada's eastern edge. Our merry little nuclear family is fortunate to be part of a community with plenty of conscientious neighbours. On a more macro scale, as citizens of a high income country, we are beneficiaries of a relatively robust public health infrastructure, educational system and government leadership. We know that this is not the case for many throughout the world.
Just seven days ago we were wrestling with whether we should be cancelling an overseas vacation. We had been wavering for a couple of weeks and then the Canadian government decided for us when one week ago they issued travel advisories recommending against non-essential international travel.
I have no idea where we will be seven days from now. Do any of us? As we seek to understand, cope and vanquish this virus, let's be responsible in our personal actions and think of others.
In these times of uncertainty it's important to celebrate kindness and giving, to keep our eyes on decency, bravery, beauty and hope. There are great things going on, small gestures that touch many people. Here are a few stories we've come across. Do you have any you would like to share? If so, drop a line through the 'Contact' tab.
A Canadian doctor is helping promote good hand washing hygiene with a version of a well-loved nursery rhyme. I saw Dr. Nisha Thampi's story on CBC's The National earlier in the week.
In Brooklyn, New York, "neighborhood kiddos are going on walks but no longer can see their friends or go to playgrounds. Some of us are putting rainbows 🌈 up in our windows for them to spot as many as they can on a walk. Like a giant neighborhood wide I spy game. If you are wondering what you can do in this time – put a rainbow in your window to spread some joy!"
Tim Gill (Rethinking Childhood) and Penny Wilson (The Playwork Primer) reached out to their considerable networks for some ideas on kid's play in these difficult times. Play in the time of cornavirus was published earlier this week. Ludicology another group of fine play folk have just published Playing through the Coronavvirus Pandemic.
Nixon Modz was sad that he wouldn't be able to see his mates at school or have a party to celebrate his 7th birthday. A tweet by his dad inviting people to send birthday wishes started trending and Nixon was flooded with reading material. Canadian political cartoonist Michael de Adder sent a one of a kind card….
And thanks to Dr. Sanjay Gupta who we have watched for so many evenings on CNN. His empathy, quiet compassion and unflagging pursuit of answers are inspirational.
Since this coronavirus has started its assault in our small corner of the world, our oldest girl has changed up her bedtime routine. She's asked us to sing her goodnight song again. It's back on the playlist after an absence of many months. There's nothing like familiarity and a little comfort to warm hearts.
We hope you will find opportunities to play over the coming weeks and months. We'll do our best and share good news about play with you. No new local coronavirus cases in China was by far the best news we heard yesterday….
And now for a five-step roadmap of how we can engage through this infographic from the UK's Eden Project Communities.
Many thanks to all the frontline and essential workers. Without you, we can't imagine where we would be. Stay safe friends.
Posted in coronavirus, deAdder, Dr. Sanjay Gupta, Eden Project, hand washing, Ludicology, outdoor neighbourhood play, Penny Wilson, play outdoors, PlayGroundology, Tim Gill, uncharted, UNESCO
Tagged Dr. Nisha Thampi


Once you have created a database file structure, you must also enable the database server daemon to allow Harmony to connect to the database. This daemon runs through the user usabatch, so this user must be created prior to installing the daemon.
By enabling the daemon that was already installed with Harmony using the chkconfig command.
By running the Harmony installation script with the -d parameter. This will also create a database file structure on your machine if none is present.
This daemon runs through the user usabatch, so this user must be created prior to installing the daemon.
NOTEThe following steps indicate how to make the database server daemon launch on boot, via the user usabatch. If you prefer, you can make the database server launch on log-in as the logged-in user. For more information, see Running the Database Server on Log-In on GNU/Linux.
When prompted, enter the password you want to assign to the user usabatch, then confirm it.
The user usabatch is now created and can be used to run Harmony daemons.
If the command returns nothing, it succeeded. The database server will launch next time you boot the machine.
The command will report whether it succeeded or failed.
In a terminal, navigate to the directory where you downloaded the installation package.
Extract the package's contents in the directory.
Switch to the directory in which the package's contents were extracted.
When prompted, confirm that you want to proceed with the installation.
The installation script will create a database file structure in /USA_DB, enable the database server daemon and start it.
NOTEThe installation script will not create a database file structure in /USA_DB if this directory already exists, whether it is a local database or a remote database mounted on the file system.


A look at some of the top stories on the Quebec cultural scene this week, including the finale of La Voix junior and the launch of the film Junior majeur.
Apparently, Quebec TV viewers just can't get enough of La Voix and La Voix junior.
The youth version of the music talent show was the most popular francophone show on TV in Quebec this fall, regularly pulling in 1.9 million viewers.
That gave the show, which is a French-language adaptation of The Voice, a market-share of around 50-per cent of the franco audience ici. Suffice it to say, no series in either the rest of Canada or in the U.S. garners that kind of market share. It's a testament to how one show can captivate the province. And it's also a reminder that these folks just love their homegrown French-language programming.
The second edition of La Voix junior wrapped on Sunday night on the TVA Network with Sydney Lallier, an 11-year-old from Granby, winning top honours and a cash prize of $25,000.
The young singer was coached on the show by pop star Marie-Mai. Lallier won it all by performing hip-hop tunes, not something you see all that often in these types of shows. She wooed the public with spirited interpretations of La force de comprendre from the pioneering Quebec hip-hop group Dubmatique and the Eminem classic Lose Yourself.
The finale Sunday was watched by just under 2 million viewers. For those who just can't get enough of the young stars of La Voix junior, they'll be performing at the Bell Centre at 3 p.m. and 7:30 p.m. on Dec. 16. They'll be accompanied by three of the coaches, Marie-Mai, Marc Dupré and Alex Nevsky.
Given how poorly things are going for the Canadiens, maybe the province's depressed hockey fans will be able to take some solace in Junior majeur, which opens across Quebec on Thursday. It is the sequel to Les pee-wee 3D: l'hiver qui a changé ma vie, a hit film from five years ago which, as the title suggests, focused on peewee hockey players in Quebec.
Five years later, the two main characters, Janeau Trudel (Antoine Olivier Pilon) and Joey Boulet (Rémi Goulet) are playing for les Saguenéens de Chicoutimi in the Quebec Major Junior Hockey League, and they're now big stars in the team's town. Their old pal Julie Morneau (Alice Morel-Michaud) is now a sports journalist covering the team.
A big part of the drama is built around how these young guys deal with the notion they're being treated like stars by the local fans. This time, the film is not in 3D, partly due to budgetary constraints but also because, as producer Christian Larouche noted in La Presse, the public is a bit bored with the format.
There was much grumbling in the cultural milieu when word leaked out early in the week via a story in Le Devoir that SODEC president Monique Simard was not going to be returning to the top job at the Quebec cultural-funding agency when her mandate runs out in early January.
The unusual wrinkle is that the board of directors at SODEC recommended the provincial government renew Simard's contract but Philippe Couillard's Liberals decided not to follow that advice.
Most figure that's because Simard has had close ties to the Parti Québécois. She was a PQ MNA from 1996 to 1998. Simard expressed her disappointment with this turn of affairs. She told Le Devoir that the biggest challenge facing SODEC is figuring out whether it has enough autonomy from the government to deal with the changing cultural landscape.
There continues to be much debate around the future of Juste Pour rire/Just For Laughs now that many of the province's top francophone comics have lined-up behind a new rival festival. A slew of comics, led by Martin Petit, have created the Festival du rire de Montréal, because they want to distance themselves from Juste Pour Rire owner Gilbert Rozon.
Rozon, who is facing numerous allegations of sexual misconduct, said he is going to sell his majority stake in Just For Laughs. But the sale hasn't happened yet. Juste Pour Rire keeps insisting it's business as usual, but the plot thickened this week when former Just For Laughs president Andy Nulman was tapped by the new festival to act as a special consultant.
Nulman, who worked for years at Just For Laughs, has great contacts in the American comedy industry and there is much speculation that he will be able to attract some high-profile U.S. talent to the upstart festival.
Others wonder if these Quebec comics aren't just taking advantage of the Rozon scandal to consolidate their power base in the lucrative comedy biz here. There is also some concern the new comedy festival may face choppy waters early on.
The standup comics might think this is a great opportunity, but it isn't that easy to start up a major festival. If you doubt that, just ask the executives at L'Équipe Spectra who attempted to create a film fest to rival the Montreal World Film Festival back in 2005. The new festival was a total and unmitigated disaster and folded after just one edition.


text:
Thread: Victoria Theatre
21st Sep 19, 21:40 #1
History Nicked from Wiki
The Victoria Theatre Salford officially opened 10 December 1900 and was last in use as a bingo hall in 2008. The original capacity was 2,000 seated, this was increased to 3,000 in 1910. Palatial Leisure Limited sold the building in September 2018.
The 2,000 seater theatre opened with the play "Sign of the Cross," performed by William Greet's company, with Edward Vincent as the Prefect and Virginia Buckle as the Christian girl Mercia. The front of the theatre was described as "red terra-cotta, divided by Ionic pilasters into five bays" and the foyer was described as "a hall 34 feet long and 18 feet wide, with marble mosaic floor, walls panelled in fibrous plaster, and hand-painted ceiling". The dimensions of the stage were also recorded as "Its width is 74 feet, the distance from the curtain line to the back wall is 40 feet, the distance from stage to grid is 50 feet, and the proscenium opening is 30 feet in width.
After a brief unsuccessful attempt to run the venue as a bingo hall in 1973 the theatre closed again. It then remained dark until the 1980s when a second attempt was successful and the bingo hall remained open until 2008. The theatre became a Grade II Listed Building on 18 January 1980
The Explore
Another one of the backlog from a trip up North, this place was a spur of the moment stop.
Its a bit of a derp to be honest, the addicts have been in there & the ground floor is stripped bare.
Fortunately some beautiful colours on the balconies survive & there is still a few bits untouched in the higher room so it makes for some good photography if you can handle the near zero light in there!
Unfortunately a bit of the roof has already gone & water ingress is slowly rotting the upper floors!
Again it appears the listing means nothing & this place will be left to fall in on itself.
9O5A0652 by Bikin Glynn, on Flickr
9O5A0662-2 by Bikin Glynn, on Flickr
Thanks given by: dewdrop, etc100, Grumpy, Hugh Jorgan, KJurbex, KPUrban_, Mearing, noiseboy72, rockfordstone, smiler, Tbolt
27th Sep 19, 17:01 #2
Tbolt
Lovely that sir and very close to me.... I really need to go and look
Don't panic, be reet!!!
4th Oct 19, 17:48 #3
Lost in Cornwall
I enjoyed that, lovely pics, Thanks.
Thanks given by: BikinGlynn
Victoria Theatre, Salford | July 2019
By TopAbandoned in forum Leisure Sites
Last Post: 31st Jul 19, 10:14
The royal victoria..Kent
By Mikeymutt in forum Hospitals & Asylums
Last Post: 26th Jul 18, 21:17
Point Nepean, Victoria
By thepetrolhead in forum Overseas Sites
Last Post: 4th May 10, 16:22
Victoria Tunnel
By BarneySchwarzenegger in forum Underground Sites
Last Post: 18th Jan 08, 23:21
Victoria Tower
By 4737carlin in forum Industrial Sites


Virginia Governor Tim Kaine has just a few weeks left in his time at the Commonwealth's Chief Executive. Recently, I sat down with the Governor for a lengthy look back at his four years in office. Kaine revealed quite a bit during our discussion, much of which I will share over the next few weeks, leading up to the inauguration of his successor Bob McDonnell.
Among the many things we discussed was the vetting process during the campaign for President, that propelled Kaine into the national spotlight. Kaine developed a very close relationship with a then, Senator Barack Obama and was one of his early backers. Even though Kaine was not very well-known across the Country, that friendship was one of the main reasons that Obama considered Virginia's Governor to be his running mate.
Kaine, who was very quiet about the vetting process at the time, told me today that he, Joe Biden and Indiana Senator Evan Bayh were Obama's three finalists. The selection process has been outlined extensively in campaign manager David Plouffe's book, "The Audacity to Win". Kaine said that he was whisked away to several covert interviews including one with Obama himself. He said around that time, the candidate told him what his thought process was.
At the time, national pundits were very skeptical that Governor Kaine had the foreign policy credentials necessary to serve as Vice President. That concern was compounded by the fact that Senator Obama's experience in foreign affairs was also not extensive. Apparently, Kaine felt the same way.
Looking back, Kaine said that Biden turned out to be the right choice. Not only because he and Obama ended up winning by such a large margin, but because the Vice President has been able to leverage his connections with members of Congress to push forward the President's agenda when it comes to health care reform.
I'll have more from my interview with the Governor in the coming days. To see my story from NBC12-TV on Kaine's reflections of his time in office, click here.
« The benefits of your off day falling on the same day as a snow storm..