text:
using device::mojom::UsbDeviceInfoPtr;
using extensions::DictionaryBuilder;
using extensions::Extension;
using extensions::PrinterProviderAPI;
using extensions::PrinterProviderPrintJob;
using extensions::TestExtensionEnvironment;

namespace printing {

namespace {

// Printer id used for requests in tests.
const char kPrinterId[] = "printer_id";

// Printer list used a result for getPrinters.
const char kPrinterDescriptionList[] =
    "[{"
    "  \"id\": \"printer1\","
    "  \"name\": \"Printer 1\""
    "}, {"
    "  \"id\": \"printer2\","
    "  \"name\": \"Printer 2\","
    "  \"description\": \"Test printer 2\""
    "}]";

// Printer capability for a printer that supportd only PWG raster.
const char kPWGRasterOnlyPrinterSimpleDescription[] =
    "{"
    "  \"version\": \"1.0\","
    "  \"printer\": {"
    "    \"supported_content_type\": ["
    "      {\"content_type\": \"image/pwg-raster\"}"
    "    ]"
    "  }"
    "}";

// Print ticket with no parameters set.
const char kEmptyPrintTicket[] = "{\"version\": \"1.0\"}";

// Print ticket that has duplex parameter set.
const char kPrintTicketWithDuplex[] =
    "{"
    "  \"version\": \"1.0\","
    "  \"print\": {"
    "    \"duplex\": {\"type\": \"LONG_EDGE\"}"
    "  }"
    "}";

// An extension with permission for 1 printer it supports.
const char kExtension1[] =
    "{"
    "  \"name\": \"Provider 1\","
    "  \"app\": {"
    "    \"background\": {"
    "      \"scripts\": [\"background.js\"]"
    "    }"
    "  },"
    "  \"permissions\": ["
    "    \"printerProvider\","
    "    \"usb\","
    "    {"
    "     \"usbDevices\": ["
    "       { \"vendorId\": 0, \"productId\": 1 }"
    "     ]"
    "    },"
    "  ],"
    "  \"usb_printers\": {"
    "    \"filters\": ["
    "      { \"vendorId\": 0, \"productId\": 0 },"
    "      { \"vendorId\": 0, \"productId\": 1 }"
    "    ]"
    "  }"
    "}";

// An extension with permission for none of the printers it supports.
const char kExtension2[] =
    "{"
    "  \"name\": \"Provider 2\","
    "  \"app\": {"
    "    \"background\": {"
    "      \"scripts\": [\"background.js\"]"
    "    }"
    "  },"
    "  \"permissions\": [ \"printerProvider\", \"usb\" ],"
    "  \"usb_printers\": {"
    "    \"filters\": ["
    "      { \"vendorId\": 0, \"productId\": 0 },"
    "      { \"vendorId\": 0, \"productId\": 1 }"
    "    ]"
    "  }"
    "}";

const char kPdfSettings[] = R"({
  "deviceName": "printer_id",
  "capabilities": "{
      \"version\": \"1.0\",
      \"printer\": {
        \"supported_content_type\": [
          {\"content_type\": \"application/pdf\"},
          {\"content_type\": \"image/pwg-raster\"}
        ]
      }
    }",
  "ticket": "{\"version\": \"1.0\"}",
  "pageWidth": 100,
  "pageHeight": 50
})";

const char kAllTypesSettings[] = R"({
  "deviceName": "printer_id",
  "capabilities": "{
      \"version\": \"1.0\",
      \"printer\": {
        \"supported_content_type\": [
          {\"content_type\": \"*/*\"}
        ]
      }
    }",
  "ticket": "{\"version\": \"1.0\"}",
  "pageWidth": 100,
  "pageHeight": 50
})";

const char kSimpleRasterSettings[] = R"({
  "deviceName": "printer_id",
  "capabilities": "{
      \"version\": \"1.0\",
      \"printer\": {
        \"supported_content_type\": [
          {\"content_type\": \"image/pwg-raster\"}
        ]
      }
    }",
  "ticket": "{\"version\": \"1.0\"}",
  "pageWidth": 100,
  "pageHeight": 50
})";

const char kInvalidSettings[] = R"({
  "deviceName": "printer_id",
  "capabilities": "{
      \"version\": \"1.0\",
      \"printer\": {
        \"supported_content_type\": [
          {\"content_type\": \"image/pwg-raster\"}
        ]
      }
    }",
  "ticket": "{}",
  "pageWidth": 100,
  "pageHeight": 50
})";

const char kDuplexSettings[] = R"({
  "deviceName": "printer_id",
  "capabilities": "{
      \"version\": \"1.0\",
      \"printer\": {
        \"supported_content_type\": [
          {\"content_type\": \"image/pwg-raster\"}
        ],
        \"pwg_raster_config\": {
          \"document_sheet_back\": \"FLIPPED\",
          \"reverse_order_streaming\": true,
          \"rotate_all_pages\": true
        },
        \"dpi\": {
          \"option\": [{
            \"horizontal_dpi\": 100,
            \"vertical_dpi\": 200,
            \"is_default\": true
          }]
        }
      }
    }",
  "ticket": "{
      \"version\": \"1.0\",
      \"print\": {
        \"duplex\": {\"type\": \"LONG_EDGE\"}
      }
    }",
  "pageWidth": 100,
  "pageHeight": 50
})";

const char kContentTypePDF[] = "application/pdf";
const char kContentTypePWG[] = "image/pwg-raster";

// Print request status considered to be successful by fake PrinterProviderAPI.
const char kPrintRequestSuccess[] = "OK";

constexpr unsigned char kPrintData[] = "print data, PDF";
constexpr size_t kPrintDataLength = sizeof(kPrintData);

// Used as a callback to StartGetPrinters in tests.
// Increases |*call_count| and records values returned by StartGetPrinters.
void RecordPrinterList(size_t* call_count,
                       std::unique_ptr<base::ListValue>* printers_out,
                       const base::ListValue& printers) {
  ++(*call_count);
  printers_out->reset(printers.DeepCopy());
}

// Used as a callback to StartGetPrinters in tests.
// Records that the test is done.
void RecordPrintersDone(bool* is_done_out) {
  *is_done_out = true;
}

// Used as a callback to StartGetCapability in tests.
// Increases |*call_count| and records values returned by StartGetCapability.
void RecordCapability(size_t* call_count,
                      std::unique_ptr<base::DictionaryValue>* capability_out,
                      base::Value capability) {
  ++(*call_count);
  const base::Value* capabilities = nullptr;
  if (capability.is_dict()) {
    capabilities = capability.FindKeyOfType(kSettingCapabilities,
                                            base::Value::Type::DICTIONARY);
  }
  *capability_out =
      capabilities ? base::DictionaryValue::From(
                         std::make_unique<base::Value>(capabilities->Clone()))
                   : nullptr;
}

// Used as a callback to StartPrint in tests.
// Increases |*call_count| and records values returned by StartPrint.
void RecordPrintResult(size_t* call_count,
                       bool* success_out,
                       std::string* status_out,
                       const base::Value& status) {
  ++(*call_count);
  bool success = status.is_none();
  std::string status_str = success ? kPrintRequestSuccess : status.GetString();
  *success_out = success;
  *status_out = status_str;
}

// Used as a callback to StartGrantPrinterAccess in tests.
// Increases |*call_count| and records the value returned.
void RecordPrinterInfo(size_t* call_count,
                       std::unique_ptr<base::DictionaryValue>* printer_info_out,
                       const base::DictionaryValue& printer_info) {
  ++(*call_count);
  printer_info_out->reset(printer_info.DeepCopy());
}

// Converts JSON string to base::ListValue object.
// On failure, returns NULL and fills |*error| string.
std::unique_ptr<base::ListValue> GetJSONAsListValue(const std::string& json,
                                                    std::string* error) {
  auto ret = base::ListValue::From(
      JSONStringValueDeserializer(json).Deserialize(nullptr, error));
  if (!ret)
    *error = "Value is not a list.";
  return ret;
}

// Converts JSON string to base::DictionaryValue object.
// On failure, returns NULL and fills |*error| string.
std::unique_ptr<base::DictionaryValue> GetJSONAsDictionaryValue(
    const std::string& json,
    std::string* error) {
  auto ret = base::DictionaryValue::From(
      JSONStringValueDeserializer(json).Deserialize(nullptr, error));
  if (!ret)
    *error = "Value is not a dictionary.";
  return ret;
}

std::string RefCountedMemoryToString(
    scoped_refptr<base::RefCountedMemory> memory) {
  return std::string(memory->front_as<char>(), memory->size());
}

// Fake PwgRasterConverter used in the tests.
class FakePwgRasterConverter : public PwgRasterConverter {
 public:
  FakePwgRasterConverter() {}
  ~FakePwgRasterConverter() override = default;

  // PwgRasterConverter implementation. It writes |data| to shared memory.
  // Also, remembers conversion and bitmap settings passed into the method.
  void Start(const base::RefCountedMemory* data,
             const PdfRenderSettings& conversion_settings,
             const PwgRasterSettings& bitmap_settings,
             ResultCallback callback) override {
    base::ReadOnlySharedMemoryRegion invalid_pwg_region;
    if (fail_conversion_) {
      std::move(callback).Run(std::move(invalid_pwg_region));
      return;
    }

    base::MappedReadOnlyRegion memory =
        base::ReadOnlySharedMemoryRegion::Create(data->size());
    if (!memory.IsValid()) {
      ADD_FAILURE() << "Failed to create pwg raster shared memory.";
      std::move(callback).Run(std::move(invalid_pwg_region));
      return;
    }

    memcpy(memory.mapping.memory(), data->front(), data->size());
    conversion_settings_ = conversion_settings;
    bitmap_settings_ = bitmap_settings;
    std::move(callback).Run(std::move(memory.region));
  }

  // Makes |Start| method always return an error.
  void FailConversion() { fail_conversion_ = true; }

  const PdfRenderSettings& conversion_settings() const {
    return conversion_settings_;
  }

  const PwgRasterSettings& bitmap_settings() const { return bitmap_settings_; }

 private:
  PdfRenderSettings conversion_settings_;
  PwgRasterSettings bitmap_settings_;
  bool fail_conversion_ = false;

  DISALLOW_COPY_AND_ASSIGN(FakePwgRasterConverter);
};

// Information about received print requests.
struct PrintRequestInfo {
  PrinterProviderAPI::PrintCallback callback;
  PrinterProviderPrintJob job;
};

// Fake PrinterProviderAPI used in tests.
// It caches requests issued to API and exposes methods to trigger their
// callbacks.
class FakePrinterProviderAPI : public PrinterProviderAPI {
 public:
  FakePrinterProviderAPI() = default;
  ~FakePrinterProviderAPI() override = default;

  void DispatchGetPrintersRequested(
      const PrinterProviderAPI::GetPrintersCallback& callback) override {
    pending_printers_callbacks_.push(callback);
  }

  void DispatchGetCapabilityRequested(
      const std::string& destination_id,
      PrinterProviderAPI::GetCapabilityCallback callback) override {
    pending_capability_callbacks_.push(std::move(callback));
  }

  void DispatchPrintRequested(
      PrinterProviderPrintJob job,
      PrinterProviderAPI::PrintCallback callback) override {
    PrintRequestInfo request_info;
    request_info.callback = std::move(callback);
    request_info.job = std::move(job);

    pending_print_requests_.push(std::move(request_info));
  }

  void DispatchGetUsbPrinterInfoRequested(
      const std::string& extension_id,
      const device::mojom::UsbDeviceInfo& device,
      PrinterProviderAPI::GetPrinterInfoCallback callback) override {
    EXPECT_EQ("fake extension id", extension_id);
    EXPECT_FALSE(device.guid.empty());
    pending_usb_info_callbacks_.push(std::move(callback));
  }

  size_t pending_get_printers_count() const {
    return pending_printers_callbacks_.size();
  }

  const PrinterProviderPrintJob* GetPrintJob(
      const extensions::Extension* extension,
      int request_id) const override {
    ADD_FAILURE() << "Not reached";
    return nullptr;
  }

  void TriggerNextGetPrintersCallback(const base::ListValue& printers,
                                      bool done) {
    ASSERT_GT(pending_get_printers_count(), 0u);
    pending_printers_callbacks_.front().Run(printers, done);
    pending_printers_callbacks_.pop();
  }

  size_t pending_get_capability_count() const {
    return pending_capability_callbacks_.size();
  }

  void TriggerNextGetCapabilityCallback(
      const base::DictionaryValue& description) {
    ASSERT_GT(pending_get_capability_count(), 0u);
    std::move(pending_capability_callbacks_.front()).Run(description);
    pending_capability_callbacks_.pop();
  }

  size_t pending_print_count() const { return pending_print_requests_.size(); }

  const PrinterProviderPrintJob* GetNextPendingPrintJob() const {
    EXPECT_GT(pending_print_count(), 0u);
    if (pending_print_count() == 0)
      return NULL;
    return &pending_print_requests_.front().job;
  }

  void TriggerNextPrintCallback(const std::string& result) {
    ASSERT_GT(pending_print_count(), 0u);
    base::Value result_value;
    if (result != kPrintRequestSuccess)
      result_value = base::Value(result);
    std::move(pending_print_requests_.front().callback).Run(result_value);
    pending_print_requests_.pop();
  }

  size_t pending_usb_info_count() const {
    return pending_usb_info_callbacks_.size();
  }

  void TriggerNextUsbPrinterInfoCallback(
      const base::DictionaryValue& printer_info) {
    ASSERT_GT(pending_usb_info_count(), 0u);
    std::move(pending_usb_info_callbacks_.front()).Run(printer_info);
    pending_usb_info_callbacks_.pop();
  }

 private:
  base::queue<PrinterProviderAPI::GetPrintersCallback>
      pending_printers_callbacks_;
  base::queue<PrinterProviderAPI::GetCapabilityCallback>
      pending_capability_callbacks_;
  base::queue<PrintRequestInfo> pending_print_requests_;
  base::queue<PrinterProviderAPI::GetPrinterInfoCallback>
      pending_usb_info_callbacks_;

  DISALLOW_COPY_AND_ASSIGN(FakePrinterProviderAPI);
};

std::unique_ptr<KeyedService> BuildTestingPrinterProviderAPI(
    content::BrowserContext* context) {
  return std::make_unique<FakePrinterProviderAPI>();
}

}  // namespace

class ExtensionPrinterHandlerTest : public testing::Test {
 public:
  ExtensionPrinterHandlerTest() = default;
  ~ExtensionPrinterHandlerTest() override = default;

  void SetUp() override {
    extensions::PrinterProviderAPIFactory::GetInstance()->SetTestingFactory(
        env_.profile(), base::BindRepeating(&BuildTestingPrinterProviderAPI));
    extension_printer_handler_ =
        std::make_unique<ExtensionPrinterHandler>(env_.profile());

    auto pwg_raster_converter = std::make_unique<FakePwgRasterConverter>();
    pwg_raster_converter_ = pwg_raster_converter.get();
    extension_printer_handler_->SetPwgRasterConverterForTesting(
        std::move(pwg_raster_converter));

    // Set fake USB device manager for extensions::UsbDeviceManager.
    mojo::PendingRemote<device::mojom::UsbDeviceManager> usb_manager;
    fake_usb_manager_.AddReceiver(usb_manager.InitWithNewPipeAndPassReceiver());
    extensions::UsbDeviceManager::Get(env_.profile())
        ->SetDeviceManagerForTesting(std::move(usb_manager));
    base::RunLoop().RunUntilIdle();
  }

 protected:
  FakePrinterProviderAPI* GetPrinterProviderAPI() {
    return static_cast<FakePrinterProviderAPI*>(
        extensions::PrinterProviderAPIFactory::GetInstance()
            ->GetForBrowserContext(env_.profile()));
  }

  device::FakeUsbDeviceManager fake_usb_manager_;
  TestExtensionEnvironment env_;
  std::unique_ptr<ExtensionPrinterHandler> extension_printer_handler_;

  // Owned by |extension_printer_handler_|.
  FakePwgRasterConverter* pwg_raster_converter_ = nullptr;

 private:
  DISALLOW_COPY_AND_ASSIGN(ExtensionPrinterHandlerTest);
};

TEST_F(ExtensionPrinterHandlerTest, GetPrinters) {
  size_t call_count = 0;
  std::unique_ptr<base::ListValue> printers;
  bool is_done = false;

  extension_printer_handler_->StartGetPrinters(
      base::BindRepeating(&RecordPrinterList, &call_count, &printers),
      base::BindOnce(&RecordPrintersDone, &is_done));

  EXPECT_FALSE(printers.get());
  FakePrinterProviderAPI* fake_api = GetPrinterProviderAPI();
  ASSERT_TRUE(fake_api);
  ASSERT_EQ(1u, fake_api->pending_get_printers_count());

  std::string error;
  std::unique_ptr<base::ListValue> original_printers(
      GetJSONAsListValue(kPrinterDescriptionList, &error));
  ASSERT_TRUE(original_printers) << "Failed to deserialize printers: " << error;

  fake_api->TriggerNextGetPrintersCallback(*original_printers, true);

  EXPECT_EQ(1u, call_count);
  EXPECT_TRUE(is_done);
  ASSERT_TRUE(printers.get());
  EXPECT_TRUE(printers->Equals(original_printers.get()))
      << *printers << ", expected: " << *original_printers;
}

TEST_F(ExtensionPrinterHandlerTest, GetPrinters_Reset) {
  size_t call_count = 0;
  std::unique_ptr<base::ListValue> printers;
  bool is_done = false;

  extension_printer_handler_->StartGetPrinters(
      base::BindRepeating(&RecordPrinterList, &call_count, &printers),
      base::BindOnce(&RecordPrintersDone, &is_done));

  EXPECT_FALSE(printers.get());
  FakePrinterProviderAPI* fake_api = GetPrinterProviderAPI();
  ASSERT_TRUE(fake_api);
  ASSERT_EQ(1u, fake_api->pending_get_printers_count());

  extension_printer_handler_->Reset();

  std::string error;
  std::unique_ptr<base::ListValue> original_printers(
      GetJSONAsListValue(kPrinterDescriptionList, &error));
  ASSERT_TRUE(original_printers) << "Error deserializing printers: " << error;

  fake_api->TriggerNextGetPrintersCallback(*original_printers, true);

  EXPECT_EQ(0u, call_count);
}

TEST_F(ExtensionPrinterHandlerTest, GetUsbPrinters) {
  UsbDeviceInfoPtr device0 =
      fake_usb_manager_.CreateAndAddDevice(0, 0, "Google", "USB Printer", "");
  UsbDeviceInfoPtr device1 =
      fake_usb_manager_.CreateAndAddDevice(0, 1, "Google", "USB Printer", "");
  base::RunLoop().RunUntilIdle();

  const Extension* extension_1 = env_.MakeExtension(
      base::test::ParseJson(kExtension1), "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa");
  const Extension* extension_2 = env_.MakeExtension(
      base::test::ParseJson(kExtension2), "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb");

  extensions::DevicePermissionsManager* permissions_manager =
      extensions::DevicePermissionsManager::Get(env_.profile());
  permissions_manager->AllowUsbDevice(extension_2->id(), *device0);

  size_t call_count = 0;
  std::unique_ptr<base::ListValue> printers;
  bool is_done = false;
  extension_printer_handler_->StartGetPrinters(
      base::BindRepeating(&RecordPrinterList, &call_count, &printers),
      base::BindOnce(&RecordPrintersDone, &is_done));

  base::RunLoop().RunUntilIdle();

  FakePrinterProviderAPI* fake_api = GetPrinterProviderAPI();
  ASSERT_TRUE(fake_api);
  ASSERT_EQ(1u, fake_api->pending_get_printers_count());

  EXPECT_EQ(1u, call_count);
  EXPECT_FALSE(is_done);
  EXPECT_TRUE(printers.get());
  EXPECT_EQ(2u, printers->GetSize());
  std::unique_ptr<base::DictionaryValue> extension_1_entry(
      DictionaryBuilder()
          .Set("id", base::StringPrintf("provisional-usb:%s:%s",
                                        extension_1->id().c_str(),
                                        device0->guid.c_str()))
          .Set("name", "USB Printer")
          .Set("extensionName", "Provider 1")
          .Set("extensionId", extension_1->id())
          .Set("provisional", true)
          .Build());
  std::unique_ptr<base::DictionaryValue> extension_2_entry(
      DictionaryBuilder()
          .Set("id", base::StringPrintf("provisional-usb:%s:%s",
                                        extension_2->id().c_str(),
                                        device1->guid.c_str()))
          .Set("name", "USB Printer")
          .Set("extensionName", "Provider 2")
          .Set("extensionId", extension_2->id())
          .Set("provisional", true)
          .Build());
  EXPECT_TRUE(printers->Find(*extension_1_entry) != printers->end());
  EXPECT_TRUE(printers->Find(*extension_2_entry) != printers->end());

  fake_api->TriggerNextGetPrintersCallback(base::ListValue(), true);

  EXPECT_EQ(1u, call_count);  // No printers, so no calls. Call count stays 1.
  EXPECT_TRUE(is_done);       // Still calls done.
  EXPECT_TRUE(printers.get());
}

TEST_F(ExtensionPrinterHandlerTest, GetCapability) {
  size_t call_count = 0;
  std::unique_ptr<base::DictionaryValue> capability;

  extension_printer_handler_->StartGetCapability(
      kPrinterId, base::BindOnce(&RecordCapability, &call_count, &capability));

  EXPECT_EQ(0u, call_count);

  FakePrinterProviderAPI* fake_api = GetPrinterProviderAPI();
  ASSERT_TRUE(fake_api);
  ASSERT_EQ(1u, fake_api->pending_get_capability_count());

  std::string error;
  std::unique_ptr<base::DictionaryValue> original_capability(
      GetJSONAsDictionaryValue(kPWGRasterOnlyPrinterSimpleDescription, &error));
  ASSERT_TRUE(original_capability)
      << "Error deserializing capability: " << error;

  fake_api->TriggerNextGetCapabilityCallback(*original_capability);

  EXPECT_EQ(1u, call_count);
  ASSERT_TRUE(capability.get());
  EXPECT_TRUE(capability->Equals(original_capability.get()))
      << *capability << ", expected: " << *original_capability;
}

TEST_F(ExtensionPrinterHandlerTest, GetCapability_Reset) {
  size_t call_count = 0;
  std::unique_ptr<base::DictionaryValue> capability;

  extension_printer_handler_->StartGetCapability(
      kPrinterId, base::BindOnce(&RecordCapability, &call_count, &capability));

  EXPECT_EQ(0u, call_count);

  FakePrinterProviderAPI* fake_api = GetPrinterProviderAPI();
  ASSERT_TRUE(fake_api);
  ASSERT_EQ(1u, fake_api->pending_get_capability_count());

  extension_printer_handler_->Reset();

  std::string error;
  std::unique_ptr<base::DictionaryValue> original_capability(
      GetJSONAsDictionaryValue(kPWGRasterOnlyPrinterSimpleDescription, &error));
  ASSERT_TRUE(original_capability)
      << "Error deserializing capability: " << error;

  fake_api->TriggerNextGetCapabilityCallback(*original_capability);

  EXPECT_EQ(0u, call_count);
}

TEST_F(ExtensionPrinterHandlerTest, Print_Pdf) {
  size_t call_count = 0;
  bool success = false;
  std::string status;

  auto print_data = base::MakeRefCounted<base::RefCountedStaticMemory>(
      kPrintData, kPrintDataLength);
  base::string16 title = base::ASCIIToUTF16("Title");

  extension_printer_handler_->StartPrint(
      title, *base::JSONReader::Read(kPdfSettings), print_data,
      base::BindOnce(&RecordPrintResult, &call_count, &success, &status));

  EXPECT_EQ(0u, call_count);
  FakePrinterProviderAPI* fake_api = GetPrinterProviderAPI();
  ASSERT_TRUE(fake_api);
  ASSERT_EQ(1u, fake_api->pending_print_count());

  const PrinterProviderPrintJob* print_job = fake_api->GetNextPendingPrintJob();
  ASSERT_TRUE(print_job);

  EXPECT_EQ(kPrinterId, print_job->printer_id);
  EXPECT_EQ(title, print_job->job_title);
  EXPECT_EQ(*base::JSONReader::Read(kEmptyPrintTicket), print_job->ticket);
  EXPECT_EQ(kContentTypePDF, print_job->content_type);
  ASSERT_TRUE(print_job->document_bytes);
  EXPECT_EQ(RefCountedMemoryToString(print_data),
            RefCountedMemoryToString(print_job->document_bytes));

  fake_api->TriggerNextPrintCallback(kPrintRequestSuccess);

  EXPECT_EQ(1u, call_count);
  EXPECT_TRUE(success);
  EXPECT_EQ(kPrintRequestSuccess, status);
}

TEST_F(ExtensionPrinterHandlerTest, Print_Pdf_Reset) {
  size_t call_count = 0;
  bool success = false;
  std::string status;

  auto print_data =
      base::MakeRefCounted<base::RefCountedBytes>(kPrintData, kPrintDataLength);
  base::string16 title = base::ASCIIToUTF16("Title");

  extension_printer_handler_->StartPrint(
      title, *base::JSONReader::Read(kPdfSettings), print_data,
      base::BindOnce(&RecordPrintResult, &call_count, &success, &status));

  EXPECT_EQ(0u, call_count);
  FakePrinterProviderAPI* fake_api = GetPrinterProviderAPI();
  ASSERT_TRUE(fake_api);
  ASSERT_EQ(1u, fake_api->pending_print_count());

  extension_printer_handler_->Reset();

  fake_api->TriggerNextPrintCallback(kPrintRequestSuccess);

  EXPECT_EQ(0u, call_count);
}

TEST_F(ExtensionPrinterHandlerTest, Print_All) {
  size_t call_count = 0;
  bool success = false;
  std::string status;

  auto print_data =
      base::MakeRefCounted<base::RefCountedBytes>(kPrintData, kPrintDataLength);
  base::string16 title = base::ASCIIToUTF16("Title");

  extension_printer_handler_->StartPrint(
      title, *base::JSONReader::Read(kAllTypesSettings), print_data,
      base::BindOnce(&RecordPrintResult, &call_count, &success, &status));

  EXPECT_EQ(0u, call_count);

  FakePrinterProviderAPI* fake_api = GetPrinterProviderAPI();
  ASSERT_TRUE(fake_api);
  ASSERT_EQ(1u, fake_api->pending_print_count());

  const PrinterProviderPrintJob* print_job = fake_api->GetNextPendingPrintJob();
  ASSERT_TRUE(print_job);

  EXPECT_EQ(kPrinterId, print_job->printer_id);
  EXPECT_EQ(title, print_job->job_title);
  EXPECT_EQ(*base::JSONReader::Read(kEmptyPrintTicket), print_job->ticket);
  EXPECT_EQ(kContentTypePDF, print_job->content_type);
  ASSERT_TRUE(print_job->document_bytes);
  EXPECT_EQ(RefCountedMemoryToString(print_data),
            RefCountedMemoryToString(print_job->document_bytes));

  fake_api->TriggerNextPrintCallback(kPrintRequestSuccess);

  EXPECT_EQ(1u, call_count);
  EXPECT_TRUE(success);
  EXPECT_EQ(kPrintRequestSuccess, status);
}

TEST_F(ExtensionPrinterHandlerTest, Print_Pwg) {
  size_t call_count = 0;
  bool success = false;
  std::string status;

  auto print_data =
      base::MakeRefCounted<base::RefCountedBytes>(kPrintData, kPrintDataLength);
  base::string16 title = base::ASCIIToUTF16("Title");

  extension_printer_handler_->StartPrint(
      title, *base::JSONReader::Read(kSimpleRasterSettings), print_data,
      base::BindOnce(&RecordPrintResult, &call_count, &success, &status));

  EXPECT_EQ(0u, call_count);

  content::RunAllTasksUntilIdle();

  FakePrinterProviderAPI* fake_api = GetPrinterProviderAPI();
  ASSERT_TRUE(fake_api);
  ASSERT_EQ(1u, fake_api->pending_print_count());

  EXPECT_EQ(TRANSFORM_NORMAL,
            pwg_raster_converter_->bitmap_settings().odd_page_transform);
  EXPECT_FALSE(pwg_raster_converter_->bitmap_settings().rotate_all_pages);
  EXPECT_FALSE(pwg_raster_converter_->bitmap_settings().reverse_page_order);
  EXPECT_TRUE(pwg_raster_converter_->bitmap_settings().use_color);

  EXPECT_EQ(gfx::Size(kDefaultPdfDpi, kDefaultPdfDpi),
            pwg_raster_converter_->conversion_settings().dpi);
  EXPECT_TRUE(pwg_raster_converter_->conversion_settings().autorotate);
  // size = vertically_oriented_size * vertical_dpi / points_per_inch x
  //        horizontally_oriented_size * horizontal_dpi / points_per_inch
  EXPECT_EQ("0,0 208x416",
            pwg_raster_converter_->conversion_settings().area.ToString());

  const PrinterProviderPrintJob* print_job = fake_api->GetNextPendingPrintJob();
  ASSERT_TRUE(print_job);

  EXPECT_EQ(kPrinterId, print_job->printer_id);
  EXPECT_EQ(title, print_job->job_title);
  EXPECT_EQ(*base::JSONReader::Read(kEmptyPrintTicket), print_job->ticket);
  EXPECT_EQ(kContentTypePWG, print_job->content_type);
  ASSERT_TRUE(print_job->document_bytes);
  EXPECT_EQ(RefCountedMemoryToString(print_data),
            RefCountedMemoryToString(print_job->document_bytes));

  fake_api->TriggerNextPrintCallback(kPrintRequestSuccess);

  EXPECT_EQ(1u, call_count);
  EXPECT_TRUE(success);
  EXPECT_EQ(kPrintRequestSuccess, status);
}

TEST_F(ExtensionPrinterHandlerTest, Print_Pwg_NonDefaultSettings) {
  size_t call_count = 0;
  bool success = false;
  std::string status;

  auto print_data =
      base::MakeRefCounted<base::RefCountedBytes>(kPrintData, kPrintDataLength);
  base::string16 title = base::ASCIIToUTF16("Title");

  extension_printer_handler_->StartPrint(
      title, *base::JSONReader::Read(kDuplexSettings), print_data,
      base::BindOnce(&RecordPrintResult, &call_count, &success, &status));

  EXPECT_EQ(0u, call_count);

  content::RunAllTasksUntilIdle();

  FakePrinterProviderAPI* fake_api = GetPrinterProviderAPI();
  ASSERT_TRUE(fake_api);
  ASSERT_EQ(1u, fake_api->pending_print_count());

  EXPECT_EQ(TRANSFORM_FLIP_VERTICAL,
            pwg_raster_converter_->bitmap_settings().odd_page_transform);
  EXPECT_TRUE(pwg_raster_converter_->bitmap_settings().rotate_all_pages);
  EXPECT_TRUE(pwg_raster_converter_->bitmap_settings().reverse_page_order);
  EXPECT_TRUE(pwg_raster_converter_->bitmap_settings().use_color);

  EXPECT_EQ(gfx::Size(200, 100),
            pwg_raster_converter_->conversion_settings().dpi);
  EXPECT_TRUE(pwg_raster_converter_->conversion_settings().autorotate);
  // size = vertically_oriented_size * vertical_dpi / points_per_inch x
  //        horizontally_oriented_size * horizontal_dpi / points_per_inch
  EXPECT_EQ("0,0 138x138",
            pwg_raster_converter_->conversion_settings().area.ToString());

  const PrinterProviderPrintJob* print_job = fake_api->GetNextPendingPrintJob();
  ASSERT_TRUE(print_job);

  EXPECT_EQ(kPrinterId, print_job->printer_id);
  EXPECT_EQ(title, print_job->job_title);
  EXPECT_EQ(*base::JSONReader::Read(kPrintTicketWithDuplex), print_job->ticket);
  EXPECT_EQ(kContentTypePWG, print_job->content_type);
  ASSERT_TRUE(print_job->document_bytes);
  EXPECT_EQ(RefCountedMemoryToString(print_data),
            RefCountedMemoryToString(print_job->document_bytes));

  fake_api->TriggerNextPrintCallback(kPrintRequestSuccess);

  EXPECT_EQ(1u, call_count);
  EXPECT_TRUE(success);
  EXPECT_EQ(kPrintRequestSuccess, status);
}

TEST_F(ExtensionPrinterHandlerTest, Print_Pwg_Reset) {
  size_t call_count = 0;
  bool success = false;
  std::string status;

  auto print_data =
      base::MakeRefCounted<base::RefCountedBytes>(kPrintData, kPrintDataLength);
  base::string16 title = base::ASCIIToUTF16("Title");

  extension_printer_handler_->StartPrint(
      title, *base::JSONReader::Read(kSimpleRasterSettings), print_data,
      base::BindOnce(&RecordPrintResult, &call_count, &success, &status));

  EXPECT_EQ(0u, call_count);

  content::RunAllTasksUntilIdle();

  FakePrinterProviderAPI* fake_api = GetPrinterProviderAPI();
  ASSERT_TRUE(fake_api);
  ASSERT_EQ(1u, fake_api->pending_print_count());

  extension_printer_handler_->Reset();

  fake_api->TriggerNextPrintCallback(kPrintRequestSuccess);

  EXPECT_EQ(0u, call_count);
}

TEST_F(ExtensionPrinterHandlerTest, Print_Pwg_InvalidTicket) {
  size_t call_count = 0;
  bool success = false;
  std::string status;

  auto print_data =
      base::MakeRefCounted<base::RefCountedBytes>(kPrintData, kPrintDataLength);
  base::string16 title = base::ASCIIToUTF16("Title");

  extension_printer_handler_->StartPrint(
      title, *base::JSONReader::Read(kInvalidSettings), print_data,
      base::BindOnce(&RecordPrintResult, &call_count, &success, &status));

  EXPECT_EQ(1u, call_count);

  EXPECT_FALSE(success);
  EXPECT_EQ("INVALID_TICKET", status);
}

TEST_F(ExtensionPrinterHandlerTest, Print_Pwg_FailedConversion) {
  size_t call_count = 0;
  bool success = false;
  std::string status;

  pwg_raster_converter_->FailConversion();

  auto print_data =
      base::MakeRefCounted<base::RefCountedBytes>(kPrintData, kPrintDataLength);
  base::string16 title = base::ASCIIToUTF16("Title");

  extension_printer_handler_->StartPrint(
      title, *base::JSONReader::Read(kSimpleRasterSettings), print_data,
      base::BindOnce(&RecordPrintResult, &call_count, &success, &status));

  EXPECT_EQ(1u, call_count);

  EXPECT_FALSE(success);
  EXPECT_EQ("INVALID_DATA", status);
}

TEST_F(ExtensionPrinterHandlerTest, GrantUsbPrinterAccess) {
  UsbDeviceInfoPtr device =
      fake_usb_manager_.CreateAndAddDevice(0, 0, "Google", "USB Printer", "");
  base::RunLoop().RunUntilIdle();

  size_t call_count = 0;
  std::unique_ptr<base::DictionaryValue> printer_info;

  std::string printer_id = base::StringPrintf(
      "provisional-usb:fake extension id:%s", device->guid.c_str());
  extension_printer_handler_->StartGrantPrinterAccess(
      printer_id,
      base::BindOnce(&RecordPrinterInfo, &call_count, &printer_info));

  EXPECT_FALSE(printer_info.get());
  FakePrinterProviderAPI* fake_api = GetPrinterProviderAPI();
  ASSERT_TRUE(fake_api);
  ASSERT_EQ(1u, fake_api->pending_usb_info_count());

  std::unique_ptr<base::DictionaryValue> original_printer_info(
      DictionaryBuilder()
          .Set("id", "printer1")
          .Set("name", "Printer 1")
          .Build());

  fake_api->TriggerNextUsbPrinterInfoCallback(*original_printer_info);

  EXPECT_EQ(1u, call_count);
  ASSERT_TRUE(printer_info.get());
  EXPECT_TRUE(printer_info->Equals(original_printer_info.get()))
      << *printer_info << ", expected: " << *original_printer_info;
}

TEST_F(ExtensionPrinterHandlerTest, GrantUsbPrinterAccess_Reset) {
  UsbDeviceInfoPtr device =
      fake_usb_manager_.CreateAndAddDevice(0, 0, "Google", "USB Printer", "");
  base::RunLoop().RunUntilIdle();

  size_t call_count = 0;
  std::unique_ptr<base::DictionaryValue> printer_info;

  extension_printer_handler_->StartGrantPrinterAccess(
      base::StringPrintf("provisional-usb:fake extension id:%s",
                         device->guid.c_str()),
      base::BindOnce(&RecordPrinterInfo, &call_count, &printer_info));

  EXPECT_FALSE(printer_info.get());
  FakePrinterProviderAPI* fake_api = GetPrinterProviderAPI();
  ASSERT_TRUE(fake_api);
  ASSERT_EQ(1u, fake_api->pending_usb_info_count());

  extension_printer_handler_->Reset();

  std::unique_ptr<base::DictionaryValue> original_printer_info(
      DictionaryBuilder()
          .Set("id", "printer1")
          .Set("name", "Printer 1")
          .Build());

  fake_api->TriggerNextUsbPrinterInfoCallback(*original_printer_info);

  EXPECT_EQ(0u, call_count);
  EXPECT_FALSE(printer_info.get());
}

}  // namespace printing


text:
How to mirror content from your smartphone to your TV – The Indian Express
Watching your favourite TV shows and movies on the big screen is always more fun. While cable TV comes with its ups and downs, smart TVs have made the experience more seamless. But in case, you don't have a smart TV at home you can simply mirror your smartphone to your television or cast the phone's phone's content on the bigger screen.
Keep in mind that there is no one way for all TVs and smartphones and it will depend on what protocols your TV supports. If you have a really old TV, say more than 10 years, a streaming dongle will be the most convenient way.
Most of the new Android TVs come with support for Google Cast. Some TVs come with support for Apple's AirPlay technology as well. Some rely on their own technology and apps to allow screen mirroring. It would be best to check what functions are supported in the TV's settings to ensure that streaming is easier.
If you have a non-smart TV, especially one which is very old, but it has an HDMI slot, the easiest way to mirror your smartphone screen and cast content to the TV is via wireless dongles like Google Chromecast or an Amazon Fire TV Stick device. There are other streaming sticks available in the market as well as such as from Flipkart's MarQ, Airtel's Xstream, though the Google and Amazon sticks are most popular.
Apps like Netflix, YouTube, Disney+Hotstar, Amazon Prime Video all support the Cast feature from Google, which lets you play the content straight from your phone, and it is mirrored onto the TV.
On Amazon Fire TV Stick, there is a screen mirroring option to display your smartphone screen onto the TV. It is available in the settings. When you enable this, it will reflect your smartphone's screen on to TV and let you access others apps on the big screen. The one advantage with the Fire TV Stick comes with its own interface with apps such as Netflix, YouTube, Disney+Hotstar, Zee5, and Apple TV are all supported.
Basically what the Google Chromecast or Amazon Fire TV Stick or any other streaming stick does is that it forms a wireless link between your smartphone and TV, without you having to rely on any kind of cable.
One thing you need to make sure though is that the Chromecast or the Fire TV Stick and the phone are on the same WiFi connection in order for the content to stream from your phone to your TV.
These streaming dongles are a useful device to have if you don't have a smart TV, and just want to cast content from your phone to your TV without too much hassle. They also support screen mirroring, where the entire smartphone screen shows on the TV. And they will work flawlessly with an older TV giving you the joys of a smart TV.
As we noted earlier, most new Android TVs or smart TVs, which have launched recently, already support the Cast function from Google. So you will not need a dongle to connect your Android phone to the TV in this case. Just press the cast option on your smartphone, and it should connect wirelessly to the TV. Make sure both are on the same WiFi network.
Once the two are linked, your smartphone screen is mirrored to the TV and you can use it on the big screen to access some other apps, and not just the streaming services. Your photos, videos, etc from the phone's storage can be also be reflected to the TV using this method.
Or you can rely on the cast buttons inside apps like Netflix, Amazon Prime Video, YouTube, to cast this content from your phone to the TV. But given that this is an Android TV, these apps should already be present on your TV. The Cast function here will let you access other content from your phone on the big screen.
For iPhone users, many TVs also come with Apple's AirPlay function supported. So you can connect your iPhone or iPad or even MacBook to the TV using this feature if your TV supports it. With the AirPlay button, content from your iPhone or any other Apple device can be streamed straight to the TV wireless. Many Samsung, LG devices in India already support AirPlay as well.
Also Read: How to clean your phone
Some TVs also come with their own apps to let you connect your smartphone. This can let you access photos, music and videos from your phone on to the TV wirelessly. You will have to download the TV manufacturer's app onto your smartphone for this connection. Once this is done and the TV and phone are linked, all the photos, music and videos from the phone's storage can be seen on the TV in the relevant setting.
This is where you need to be sure of compatibility, and in some cases the support is limited to older Android devices. You can rely on the HDMI port of your TV to connect the smartphone, but you will need to check if phone supports HDMI output and you will need a compatible cable, which is supported by the device as well. Some older Android devices did come with micro-HDMI ports, but now most phones have a single Type-C USB port at the bottom.
So you will need to rely on converters or adapters if you want to link the TV to the phone via the HDMI port. However, this method will ensure that the charging port of your phone is occupied. You will be able to access videos you have shot on your phone on the TV via this, but copy-right protected content won't work via this method.
BMC to convert 1,000 rooms in each ward into quarantine facilities
Download Dragon Age: Absolution (Season 1) {English With Subtitles} WeB-DL 720p [110MB] || 1080p [500MB] – MoviesMod
Tens of thousands march in Vienna against COVID measures before lockdown – Reuters
China says spread of Covid 'impossible' to track as infections soar in Beijing – The Guardian
France vs Morocco – World Cup: Team news, start time, channel – Daily Mail
5,000 African Startups From Google Hustle Academy Programme – Leadership News
2023: Obasanjo, Atiku started fighting 'after chopping Nigeria's … – Daily Post Nigeria
Pets and 4th of July fireworks: How to keep scared dogs and cats calm, safety tips for owners – KGO-TV

redpajama_set_name: RedPajamaCommonCrawl


Structural pounding is commonly observed phenomenon during major ground motion, which can cause both structural and architectural damages. To reduce the amount of damage from pounding, the best and effective way is to increase the separation distance. Generally, existing design procedures for determining the separation distance between adjacent buildings subjected to structural pounding are based on approximations of the buildings\' peak relative displacement. These procedures are based on unknown safety levels. The aim of this research is to estimate probabilistic separation distance between adjacent structures by considering the variability in the system and uncertainties in the earthquakes characteristics through comprehensive numerical simulations. A large number of models were generated using a robust Monte-Carlo simulation. In total, 6.54 million time-history analyses were performed over the adopted models using an ensemble of 25 ground motions as seismic input within OpenSees software. The results show that a gap size of 50%, 70% and 100% of the considered design code for the structural periods in the range of 0.1-0.5 s, leads to have the probability of pounding about 41.5%, 18% and 5.8%, respectively. Finally, based on the results, two equations are developed for probabilistic determination of needed structural separation distance.
Within a probabilistic framework, this paper addresses the determination of the static structural response of beams and frames with partially restrained (semi-rigid) connections. The flexibility of the nodal connections is incorporated via an idealized linear-elastic behavior of the beam constraints through the use of rotational springs, which are here considered uncertain for taking into account the largely scattered results observed in experimental findings. The analysis is conducted via the Probabilistic Transformation Method, by modelling the spring stiffness terms (or equivalently, the fixity factors of the beam) as uniformly distributed random variables. The limit values of the Eurocode 3 fixity factors for steel semi-rigid connections are assumed. The exact probability density function of a few indicators of the structural response is derived and discussed in order to identify to what extent the uncertainty of the beam constraints affects the resulting beam response. Some design considerations arise which point out the paramount importance of probability-based approaches whenever a comprehensive experimental background regarding the stiffness of the beam connection is lacking, for example in steel frames with semi-rigid connections or in precast reinforced concrete framed structures. Indeed, it is demonstrated that resorting to deterministic approaches may lead to misleading (and in some cases non-conservative) outcomes from a design viewpoint.
This paper presents a method for detecting damage in irregular 2D and 3D continuum structures based on combination of wavelet transform (WT) with fuzzy inference system (FIS) and particle swarm optimization (PSO). Many damage detection methods study regular structures. This method studies irregular structures and doesn\'t need response of healthy structures. First the damaged structure is analyzed with finite element methods, and damage response is obtained at the finite element points that have irregular distance, secondly the FIS, which is optimized by PSO is used to obtain responses at points, having equal distance by response at those points that previously obtained by the finite element methods. Then a 2D (for 2D continuum structures) or a 3D (for 3D continuum structures) matrix is performed by equal distance point response. Thirdly, by applying 2D or 3D wavelet transform on 2D or 3D matrix that previously obtained by FIS detail matrix coefficient of WT is obtained. It is shown that detail matrix coefficient can determine the damage zone of the structure by perturbation in the damaged area. In order to illustrate the capability of proposed method some examples are considered.
In a previous study, design charts where proposed to help the torsional design of axially restricted reinforced concrete (RC) beams with squared cross section. In this article, new design charts are proposed to cover RC beams with rectangular cross section. The influence of the height to width ratio of the cross section on the behavior of RC beams under torsion is firstly shown by using theoretical and experimental results. Next, the effective torsional strength of a reference RC beam is computed for several values and combinations of the study variables, namely: height to width ratio of the cross section, concrete compressive strength, torsional reinforcement ratio and level of the axial restraint. To compute the torsional strength, the modified Variable Angle Truss Model for axially restricted RC beams is used. Then, an extensive parametric analysis based on multivariable and nonlinear correlation analysis is performed to obtain nonlinear regression equations which allow to build the new design charts. These charts allow to correct the torsional strength in order to consider the favourable influence of the compressive axial stress that arises from the axial restraint.
The current experimental study is the reinforcement of the simple curvature vault masonry structures. In this study, we discuss complex structure include vault and rib cover with two radii and actual dimensions under a vertical load. The unreinforced structure data were compared with analysis data. The analysis data are in good agreement with experimental data. In the first experiment, a structure without reinforcement is tested and according to the test results, the second structure was reinforced using the carbon polymer fibers and the same test is done to see the effects of reinforcement. Based on the test results of the first structure, the first cracks are created in the vault. Moreover, the reinforcement with carbon fibers will increase the loading capacity of the structure around 35%.
In this paper, the tensile failure behaviour of transversally bedding layers was numerically simulated by using particle flow code in two dimensions. Firstly, numerical model was calibrated by uniaxial, Brazilian and triaxial experimental results to ensure the conformity of the simulated numerical model\'s response. Secondly, 21 circular models with diameter of 54 mm were built. Each model contains two transversely bedding layers. The first bedding layer has low mechanical properties, less than mechanical properties of intact material, and second bedding layer has high mechanical properties, more than mechanical properties of intact material. The angle of first bedding layer, with weak mechanical properties, related to loading direction was 0o, 15o, 30o, 45o, 60o, 75o and 90o while the angle of second layer, with high mechanical properties, related to loading direction was 90o, 105o, 120o, 135o, 150o,160o and 180o. Is to be note that the angle between bedding layer was 90o in all bedding configurations. Also, three different pairs of the thickness was chosen in models; i.e., 5 mm/10 mm, 10 mm/10 mm and 20 mm/10 mm. The result shows that In all configurations, shear cracks develop between the weaker bedding layers. Shear cracks angel related to normal load change from 0o to 90o with increment of 15o. Numbers of shear cracks are constant by increasing the bedding thickness. It\'s to be note that in some configuration, tensile cracks develop through the intact area of material model. There is not any failure in direction of bedding plane interface with higher strength.
In this paper, the effects of particle size and model scale of concrete has been investigated on the failure mechanism of PFC2D numerical models under uniaxial compressive test. For this purpose, rectangular models with same particle sizes and different model dimensions, i.e., 3 mmx6 mm, 6 mmx12 mm, 12 mmx24 mm, 25 mmx50 mm and 54 mmx108 mm, were prepared. Also rectangular models with dimension of 54 mmx108 mm and different particle sizes, i.e., 0.27 mm, 0.47 mm, 0.67 mm, 0.87 mm, 1.07 mm, 1.87 mm and 2.27 mm were simulated using PFC2D and tested under uniaxial compressive test. Concurrent with uniaxial test, direct shear test was performed on the numerical models. Dimension of the models were 75x100 mm. Two narrow bands of particles with dimension of 37.5 mmx20 mm were removed from upper and lower of the model to supply the shear test condition. The particle sizes in the models were 0.47 mm, 0.57 mm, 0.67 mm and 0.77 mm. The result shows that failure pattern was affected by model scale and particle size. The uniaxial compressive strength and shear strength were increased by increasing the model scale and particle size.
In this study, we investigate the vibration of single-walled carbon nanotubes embedded in a polymeric matrix using nonlocal elasticity theories with account arbitrary boundary conditions effects. A Winkler type elastic foundation is employed to model the interaction of nanobeam and the surrounding elastic medium. Influence of all parameters such as nonlocal small-scale effects, Winkler modulus parameter, vibration mode and aspect ratio of nanobeam on the vibration frequency are analyzed and discussed. The mechanical properties of carbon nanotubes and polymer matrix are treated and an analytical solution is derived using the governing equations of the nonlocal Euler-Bernoulli beam models. Solutions have been compared with those obtained in the literature and The results obtained show that the non-dimensional natural frequency is significantly affected by the small-scale coefficient, the vibrational mode number and the elastic medium.
In this paper, the effect of homogenization models on stress analysis is presented for functionally graded plates (FGMs). The derivation of the effective elastic proprieties of the FGMs, which are a combination of both ceramic and metallic phase materials, is of most of importance. The majority of studies in the last decade, the Voigt homogenization model explored to derive the effective elastic proprieties of FGMs at macroscopic-scale in order to study their mechanical responses. In this work, various homogenization models were used to derive the effective elastic proprieties of FGMs. The effect of these models on the stress analysis have also been presented and discussed through a comparative study. So as to show this effect, a refined plate theory is formulated and evaluated. The number of unknowns and governing equations were reduced by dividing the transverse displacement into both bending and shear parts. Based on sinusoidal variation of displacement field trough the thickness, the shear stresses on top and bottom surfaces of plate were vanished and the shear correction factor was avoided. Governing equations of equilibrium were derived from the principle of virtual displacements. Analytical solutions of the stress analysis were obtained for simply supported FGM plates. The obtained results of the displacements and stresses were compared with those predicted by other plate theories available in the literature. This study demonstrates the sensitivity of the obtained results to different homogenization models and that the results generated may vary considerably from one theory to another. Finally, this study offers benchmark results for the multi-scale analysis of functionally graded plates.
Mode II delamination propagation is an important damage mode in laminated composites and this paper aims to investigate the behavior of this damage in laminated composite materials using acoustic emission (AE) technique. Three different lay-ups of glass/epoxy composites were subjected to mode II delamination propagation and generated AE signals were recorded. In order to investigate the propagation of delamination behavior of these specimens, AE signals were analyzed using Wavelet Packet Transforms (WPT) and Fast Fourier Transform (FFT). In addition, conventional AE analyses were used to enhance understanding of the propagation of delamination damage. The results indicate that different fracture mechanisms were the main cause of the AE signals. The dominant mechanisms in all the specimens were matrix cracking, fiber/matrix debonding and fiber breakage, with varying percentage of the damage mechanisms for each lay-up. Scanning Electron Microscopy (SEM) observations were in accordance to the AE results.


R&G Aero Crash Protectors feature our stylish, aerodynamic Aero Bobbins and are available in Black colour options. Suitable for the BMW F800R '15- models onwards. Offering core motorcycle protection, keeping the frame and other critical components off the ground in the event of a crash or slide.
BMW F800R '09-'14.R&G Aero Bobbins are a stylish, aerodynamic, teardrop shaped bobbin improving on the original good looks of our highly successful and popular standard round bobbins. Fitted with a removable end cap which hides the bobbins fittings, this sleek new design looks superb and is a winner on road and track!
This Engine Case Cover (Left Hand Side) is suitable for the BMW F800GT ('13- onwards), BMW F800R '09-'13 and BMW F800ST '07-'12 models providing essential core protection.
This Engine Case Cover (Right Hand Side) is suitable for the BMW F800GT '12-'16, BMW F800R '09-, BMW F800ST '05- and F800S '05-'08 models providing essential core protection.
Kaoko Throttle Stabilizer for BMW S1000RR (2010 -) and HP4 (2013-) F800R (-2014).
Kaoko Throttle Stabilizer for BMW F800R (2015-), S1000R (2015-).
These fork protectors are suitable for the BMW F800R, F800S & F800ST up to 2014.
This 4-piece Tank Traction Grip set has been specially designed for the BMW F800 R '09- models.
This R&G Fender Extender is compatible with the BMW F800R/S/ST ('09-'14) models.
This specific exhaust fits the BMW F800GT '13- and F800T '13- models and available in the "Serket" styles, so available in a range of finishes.


How do I automatically fill in login forms when launching a website?
While you can launch websites directly from the Windows software, it is recommended to also install one of the available browser add-ons to allow for logging in automatically.
Can I use the Windows version of Password Tote if I am not a Premium user?
The use of the Windows version and other desktop or mobile versions requires a Premium account.


Selling desserts in grocery stores is a $25 billion business — and it's one that Nick Yates, chairman of Reis & Irvy's, describes as broken. Retailers spend thousands to rent and fill freezer space, only to be left hoping and praying those frozen treats actually sell. But there may be a better way. In the latest Unattended Retail Tracker, Yates gives PYMNTS the inside scoop on how his company is hoping to disrupt that business model and transform the industry with automated vending machines.
Supermarkets across the country can no longer simply rely on stores filled with fresh produce and groceries to keep customers coming back.
In national chains like Stop and Shop and Shaw's Supermarkets, in-store coffee shops serving freshly brewed Dunkin' Donuts coffee are never more than a few aisles away. Fellow giants like Kroger and Target have similarly added Starbucks stores inside their locations in hopes of luring shoppers in need of a caffeine kick.
More recently, many supermarkets have been experimenting with frozen treats dispensed by vending machines. One such player that is helping stores lure customers by their sweet teeth is unattended retail technology provider Reis & Irvy's, which is in the process of rolling out its frozen yogurt vending machines at more than 100 franchise locations in the country.
According to company chairman Nick Yates, on-demand frozen yogurt and ice cream for grocery store shoppers is only the beginning. In a recent interview for the April Unattended Retail Tracker™, Yates discussed Reis & Irvy's current vending machine offering and its plans for the future.
The company's debut machines were created in conjunction with South Carolina-based vending machine technology provider Flex Ltd. and Robofusion, an interactive robotic kiosk maker based in Singapore.
While a prototype was built when work first began on the idea nearly a decade ago, it took years to craft a device that would be viable in American supermarkets. After almost 10 years of designing and creating software and robotic components, the machines now resemble a common fixture on the new vending machine scene, Yates explained, making them both easy to use and familiar to customers.
The Reis & Irvy's machines are capable of dispensing two soft-serve treats: frozen yogurt or ice cream. Customers place an order via an iPad attached to the machine, which allows them to swirl two flavors together and add toppings, layers or other special treats. They can also choose whether to be served by one of two robotic arms: Reis or Irvy.
The company partnered with Dannon, the world's largest frozen yogurt supplier, to dispense the frozen treats. The pair is currently working to create new Reis & Irvy's-branded dessert options, exclusively available via the machines.
Serving soft-serve via robots isn't the only way the company has looked to embrace technological innovations, however. It is eager to add any upgrade that could make the machines more convenient, Yates explained. That includes making the payment experience easier and more enjoyable for customers.
Reis & Irvy's machines allow consumers to pay for purchases with cash, debit cards and credit cards, but they also accept mobile wallet and cryptocurrencies, like bitcoin. Going forward, the company plans to add more cryptocurrencies and other embedded payment methods.
The goal is to bring a new distribution model, driven by consumer experiences and convenience, to dessert retail sales. The current model — in which companies rent freezer space, fill it with product and hope it sells — is "flawed" and in need of an upgrade, according to Yates.
It seems that unattended convenience and customers' control of choice has the future of dessert looking sweet.


text:
. ./scripts/functions.sh

# TASK 2: Setup Istio

# Font colors
export CYAN='\033[1;36m'
export GREEN='\033[1;32m'
export NC='\033[0m' # No Color

# Create a log file and send stdout and stderr to console and log file
mkdir -p logs
export LOG_FILE=setup-istio-$(date +%s).log
touch ./logs/${LOG_FILE}
exec 2>&1
exec &> >(tee -i ./logs/${LOG_FILE})

export VARS_FILE=./vars/vars.sh
source ./vars/vars.sh

# Define your OPS and DEV clusters here
# OPS clusters will get the replicated controlplane configs
# DEV clusters will get the shared control plane configs
# OPS cluster number and DEV project number should match i.e. OPS_GKE_1 cluster will
# service as the controlplane for all DEV1  GKE clusters and so on
# In the current setup, you have two OPS clusters and two associated DEV clusters for each OPS cluster as shown below

declare -a OPS_CLUSTER_CONTEXTS
export OPS_CLUSTER_CONTEXTS=(
    ${OPS_GKE_1}
    ${OPS_GKE_2}
)

declare -a OPS_CLUSTER_NAMES
export OPS_CLUSTER_NAMES=(
    ${OPS_GKE_1_CLUSTER}
    ${OPS_GKE_2_CLUSTER}
)

# Define OPS cluster deployments - the full Istio controlplane
declare -a OPS_ISTIO_DEPLOYMENTS
export OPS_ISTIO_DEPLOYMENTS=(grafana
                          istio-citadel
                          istio-ingressgateway
                          istio-egressgateway
                          istio-galley
                          istio-pilot
                          istio-policy
                          istio-telemetry
                          istio-tracing
                          istio-sidecar-injector
                          istiocoredns
                          kiali
                          prometheus
                          )

# Define OPS cluster control plane services, namely pilot, telemetry and policy
declare -a ISTIO_CONTROLPLANE_SERVICES
export ISTIO_CONTROLPLANE_SERVICES=(
    istio-pilot
    istio-policy
    istio-telemetry
)

# Each OPS cluster must have an associated DEV cluster array
declare -a OPS_1_DEV_CLUSTER_CONTEXTS
export OPS_1_DEV_CLUSTER_CONTEXTS=(
    ${DEV1_GKE_1}
    ${DEV1_GKE_2}
)

declare -a OPS_1_DEV_CLUSTER_NAMES
export OPS_1_DEV_CLUSTER_NAMES=(
    ${DEV1_GKE_1_CLUSTER}
    ${DEV1_GKE_2_CLUSTER}
)

declare -a OPS_2_DEV_CLUSTER_CONTEXTS
export OPS_2_DEV_CLUSTER_CONTEXTS=(
    ${DEV2_GKE_1}
    ${DEV2_GKE_2}
)

declare -a OPS_2_DEV_CLUSTER_NAMES
export OPS_2_DEV_CLUSTER_NAMES=(
    ${DEV2_GKE_1_CLUSTER}
    ${DEV2_GKE_2_CLUSTER}
)

# Define deployments running in shared clusters
# only citadel, sidecar-injector and optionally coredns should be running
declare -a DEV_ISTIO_DEPLOYMENTS
export DEV_ISTIO_DEPLOYMENTS=(
        istio-citadel
        istio-sidecar-injector
        istiocoredns
        )

# echo -e "\n${CYAN}Getting Istio...${NC}"
# gsutil -m cp -r gs://${TF_ADMIN}/ops/istio-${ISTIO_VERSION} .

echo -e "\n${CYAN}Creating helm template using Istio replicated control plane values...${NC}"
helm template ./istio-${ISTIO_VERSION}/install/kubernetes/helm/istio \
--name istio --namespace istio-system --values ./istio/01_istio-replicated-controlplane-values.yaml \
> ./tmp/02_istio-replicated-controlplane-manifest.yaml

echo -e "\n${CYAN}Copying Istio replicated control plane manifests to ops cluster k8s-repo folders...${NC}"
for ops_cluster in ${OPS_CLUSTER_NAMES[@]}
do
    cp ./tmp/02_istio-replicated-controlplane-manifest.yaml ./k8s-repo/${ops_cluster}/.
done

echo -e "\n${CYAN}Committing and pushing to k8s-repo to deploy Istio on ops clusters...${NC}"
cd ./k8s-repo
git add . && git commit -am "deploy istio controlplane to ops clusters"
git push google master
cd ..

echo -e "\n${CYAN}Waiting until all deployments are ready...${NC}"
for cluster in ${OPS_CLUSTER_CONTEXTS[@]}
    do
        for deployment in ${OPS_ISTIO_DEPLOYMENTS[@]}
            do
                is_istio_deployment_ready ${cluster} ${deployment}
            done
    done
echo -e "\n${CYAN}All Istio deployments are ready in ops clusters.${NC}"

echo -e "\n${CYAN}Exposing pilot, policy and telemetry using ILB...${NC}"
for cluster in ${OPS_CLUSTER_CONTEXTS[@]}
    do
        for service in ${ISTIO_CONTROLPLANE_SERVICES[@]}
            do
                expose_istio_svc_via_ilb ${cluster} ${service}
            done
    done
echo -e "\n${CYAN}Pilot, policy and telemetry patched for ILB.${NC}"

echo -e "\n${CYAN}Waiting for ILB IP address assignments...${NC}"
for cluster in ${OPS_CLUSTER_CONTEXTS[@]}
    do
        for service in ${ISTIO_CONTROLPLANE_SERVICES[@]}
            do
                get_istio_svc_ingress_ip ${cluster} ${service}
            done
    done
echo -e "\n${CYAN}ILB IP addresses assigned.${NC}"

echo -e "\n${CYAN}Exporting ILB IP as variables...${NC}"
for idx in ${!OPS_CLUSTER_CONTEXTS[@]}
    do
        ops_idx=$((idx + 1))
        echo -e "export OPS_GKE_${ops_idx}_PILOT_ILB_IP=$(kubectl --context ${OPS_CLUSTER_CONTEXTS[idx]} -n istio-system get svc istio-pilot -o json | jq -r '.status.loadBalancer.ingress[].ip')" | tee -a ${VARS_FILE}
        echo -e "export OPS_GKE_${ops_idx}_POLICY_ILB_IP=$(kubectl --context ${OPS_CLUSTER_CONTEXTS[idx]} -n istio-system get svc istio-policy -o json | jq -r '.status.loadBalancer.ingress[].ip')" | tee -a ${VARS_FILE}
        echo -e "export OPS_GKE_${ops_idx}_TELEMETRY_ILB_IP=$(kubectl --context ${OPS_CLUSTER_CONTEXTS[idx]} -n istio-system get svc istio-telemetry -o json | jq -r '.status.loadBalancer.ingress[].ip')" | tee -a ${VARS_FILE}
    done

source ./vars/vars.sh

for idx in ${!OPS_CLUSTER_CONTEXTS[@]}
    do
        ops_idx=$((idx + 1))
        echo -e "\n${CYAN}Creating helm template using Istio shared control plane values for dev${ops_idx} clusters...${NC}"

        PILOT_ILB_IP=OPS_GKE_${ops_idx}_PILOT_ILB_IP
        POLICY_ILB_IP=OPS_GKE_${ops_idx}_POLICY_ILB_IP
        TELEMETRY_ILB_IP=OPS_GKE_${ops_idx}_TELEMETRY_ILB_IP

        helm template ./istio-${ISTIO_VERSION}/install/kubernetes/helm/istio \
        --name istio-remote --namespace istio-system \
        --values ./istio/01_istio-shared-controlplane-values.yaml \
        --set global.remotePilotAddress=${!PILOT_ILB_IP} \
        --set global.remotePolicyAddress=${!POLICY_ILB_IP} \
        --set global.remoteTelemetryAddress=${!TELEMETRY_ILB_IP} > ./tmp/02_istio-shared-controlplane-dev${ops_idx}-manifest.yaml

        TMP_VAR="OPS_${ops_idx}_DEV_CLUSTER_NAMES"
        declare -a DEV_CLUSTER_NAMES="${TMP_VAR}[@]"

        for dev_cluster in ${!DEV_CLUSTER_NAMES}
            do
                echo -e "\n${CYAN}Copying Istio shared control plane manifests to the ${dev_cluster} cluster k8s-repo folders...${NC}"
                cp ./tmp/02_istio-shared-controlplane-dev${ops_idx}-manifest.yaml ./k8s-repo/${dev_cluster}/.
            done
    done

echo -e "\n${CYAN}Committing and pushing to k8s-repo to deploy Istio on dev clusters...${NC}"
cd ./k8s-repo
git add . && git commit -am "deploy istio to dev clusters"
git push google master
cd ..

echo -e "\n${CYAN}Waiting until all dev deployments are ready...${NC}"
for idx in ${!OPS_CLUSTER_CONTEXTS[@]}
    do
        ops_idx=$((idx + 1))
        TMP_VAR="OPS_${ops_idx}_DEV_CLUSTER_CONTEXTS"
        declare -a DEV_CLUSTER_CONTEXTS="${TMP_VAR}[@]"

        for dev_cluster in ${!DEV_CLUSTER_CONTEXTS}
            do
            for deployment in ${DEV_ISTIO_DEPLOYMENTS[@]}
                do
                    is_istio_deployment_ready ${dev_cluster} ${deployment}
                done
            done
    done
echo -e "\n${CYAN}All Istio deployments are ready in dev clusters.${NC}"

redpajama_set_name: RedPajamaGithub


Working with startups is exciting yet challenging. As during the teething phase, startups are quite volatile and you hardly find sustainability. Many startups even struggle to meet their liabilities and glide into debts earlier than expected. In such conditions, it is very hard to decide for many to start their career with a startup or a well-established organization.
Before jumping into any decision, I would like to withdraw your attention towards following main factors to ensure, you pick the right organization at the very start of your career.
The first step even before applying for any job is, self-assessment. You need to ask yourself the very basic question is what value could you possibly bring to the marketplace? Once you have pondered on this question, your personality, competencies, goals, and values will automatically find the right direction.
After completing swift analysis about yourself. Your next step should be shortlisting few startups which fit with your profile and excite you enough to apply for the suitable position.
Google is at your disposal. You could enlighten yourself by searching maximum information about those shortlisted startups. Focus more on the team they have in the initial phase, as those will be the people who will make or break the startup.
If you have properly completed first two steps, then you won't find any difficulties in going for a match. Choose your startup and give it a full go.
Once you are onboard with your favorite startup, now your focus should be only on delivering your best and career progression. Like Jim Rohn said. The right question is not what you are getting but what you are becoming. Keep pondering on this question and you will soon find out whether you are growing or not.
Hopefully, my first-hand experience will give you enough insight to kickstart your career with your chosen startups.


text:
Joe Biden Drops In Latest Poll But Still Holds Lead Over Democratic Primary Challengers
By CBS3 Staff June 11, 2019 at 3:46 pm
Filed Under:2020 election news, 2020 Presidential Election, Delaware news, Local, Local TV
PHILADELPHIA (CBS) – Former Vice President Joe Biden remains out front in the latest Democratic primary poll, but his lead is narrowing somewhat as his numbers have gone flat. Biden holds an 11-point advantage over his next closest rival, Vermont Sen. Bernie Sanders, according to a Quinnipiac University National Poll released Tuesday.
Biden leads Democrats and voters leaning Democratic with 30% – down from 38% in April – but Sanders, Massachusetts Sen. Elizabeth Warren and South Bend Mayor Pete Buttigieg are picking up steam in the latest poll.
Sanders finished second in the latest poll with 19% – up 3% from Quinnipiac's May 21 poll.
'We Are In A Climate Emergency': Joe Biden Pitching Over $5 Trillion Climate Plan
Warren was third at 15%, a two-point increase from last month's poll. Buttigieg came in fourth at 8%, up from 5% in last month's poll.
California Sen. Kamala Harris was fifth with 7% and former Texas Rep. Beto O'Rourke was sixth at 6%.
'I've Never Forgotten Where I Came From': Joe Biden Hits Back At President Trump's Claim He 'Deserted' Pennsylvania
No other Democrat running had more than 1% with 15 candidates not even cracking 1%. There are 24 total candidates running for the Democratic nomination.
In the 2020 race for president, Biden also remains ahead of President Donald Trump by 13 points – 53% to 40%.
Sanders has a nine-point lead over Trump (51% to 42%), Harris has an eight-point lead over Trump (49% to 41%), Warren has a seven-point lead Trump (49% to 42%) and Buttigieg has a five-point lead over Trump (47% to 42%).
CBS3 Staff
More from CBS3 Staff


Chris and I have talked about getting a puppy sister for Kita for years, but the timing never seemed right. Siberian Huskies are very social dogs and Kita seemed lonely lately, so we decided that this summer would be a good time to bring in a new family member. Kita is the coolest adult dog in the world, but Siberian Huskies puppies are very tough to raise and I thought one Husky at a time was enough for now. I also felt it was important to adopt a mixed breed as they are less likely to find homes.
Pearl the puppy has webbed feet so we are almost positive that she is part Labrador Retriever, but we are unsure about her other breed(s). Her legs are very long and her tail is long and thin, but overall she is a much smaller dog than Kita was at her age. We aren't sure of her exact age, because we are her 4th home, but when we got her at the end of July, we were told that she was 2-3 months old, so right now, she's likely about 5 months old.
Pearl has separation anxiety to the point that she cannot be left alone for a second. This is probably due to her being taken from her mother at a very young age. Luckily, she's usually alright if Kita or one of our cats are in her line of vision, but whenever Kita goes outside without her, she throws a temper tantrum, howling and crying until he comes back. To make it easier on her, Kita now does his business very quickly and runs back in the house to see her. In the mornings, when I am making coffee in the kitchen, our cat Seph will sit near her cage until I come back into the living room.
If I am out of her line of vision at night, because our bed is too high for her to see the top, I have to remind her that I'm still in the room or she will begin to whimper. My cat, Zoey has actually figured this out, so he lays at the end of the bed where Pearl can see him. This is likely due to him being annoyed by the howling, but I do appreciate his help.
If she is particularly lonely, she works herself into such a frenzy that she exhausts herself and falls asleep. Kita usually tries to make sure this doesn't happen by laying next to her crate or bringing her a toy. He has very much become a father figure to her and is very attentive to her needs. Her behavior is getting a little better over time as she seems to be realizing that we always come back.
This is definitely a new chapter in our lives, but we are facing it patiently and we look forward to watching her grow up. It is very cool that our other pets are helping us keep her calm, and I am so proud of them as I know this is a major disruption in their lives that they didn't expect.


After passing Key West Naval Air Station on Boca Chica Key the trail crosses Stock Island. Then there's a short bridge leading to Key West itself. I turned left there, as the Overseas Heritage Trail abandons US 1 and heads toward the south shore of the island along A1A, Roosevelt Blvd. Seen here is the first view of the open waters of Florida Straight after heading south on A1A beside Cow Key Channel for about a mile. This is about where I ended today's long hike - it was getting close to sunset as I trudged into town. Technically this is the city of Key West, but the end of the trail - the Southernmost Point - is still almost four miles away.
Today I did twenty-three miles - more than I had intended - between Big Pine Key and the island on which the city of Key West sits, which I guess is called Key West too.
The landscape is different here than on the middle keys. The geography is so flat, and so perfectly poised right around sea level, that in many places it's hard to distinguish between land and sea.
Where mangroves get a foothold they can create land. When storms come along and uproot them, their little islands get washed away.What would the birds do for vantage points if not for human construction in this pancake-flat country?
The bike path follows closely beside the road everywhere today except for a section on Summerland Key where a boardwalk takes the hiker/biker north for a walk beside a shallow lagoon.
Tomorrow, unless I drop dead overnight, I'm going to reach the destination I've had in my sights since I left the Appalachian Trail more than four months ago. Watch this space.


Congratulations to my colleague at Arcade, Dr. Stephen Weismann, for a pair of stellar advance reviews for his book Chaplin: A Life. Publisher's Weekly called it an "engaging…portrait of how a cinema artist is created and how he practices his craft," while the rock 'em, sock 'em Kirkus says it's "a fresh entry in the evergreen field of works devoted to Charlie Chaplin," as well as a "perceptive, literate take on the great screen clown." Awesome.
I've begged, borrowed, and cajoled my way into getting an advance copy of the book, and I'll let you know my thoughts on it, right here, as soon as possible. If you're even a casual reader of this blog, you know that Chaplin is one of my Very Favorite People Ever, and I'm really looking forward to reading this book.
This entry was posted in coming attractions, publishing, The Circus and tagged Charlie Chaplin. Bookmark the permalink.


To filter salaries for Bartender in Chicago, IL Area, Sign In or Register.
How much does a Bartender make in Chicago, IL?
The average salary for a Bartender is $21,510 in Chicago, IL. Salaries estimates are based on 132 salaries submitted anonymously to Glassdoor by Bartender employees in Chicago, IL.


text:
New Era Kicks Off For Dallas Boys Basketball Wednesday
Posted by Jeremy McDonald on December 3, 2019
DALLAS, Ore.– There's nerves obviously on the eve of the season for Jordan Sollman as he enters his first game as Varsity Head Coach in eight years at Dallas High School.
"A lot of it is just excitement. You've only been going at it for about two weeks here in the gym, the regular season…I've seen some of these guys in the summer. I'm just curious," said Sollman.
Curious to see how they react to adversity and build from that? From their first team meeting, the Dragons boys team want to go out and play a complete 32-minutes of basketball and face that adversity accordingly.
It's been since 2015 that the Dallas Boys Basketball team reached the 5A playoffs, reaching the first round before falling to eventual State Runner-Up Wilsonville that year as Sollman looks to build a foundation this year to build from for the years to come.
"We've also been preaching hard on building a new identy. There's been some struggle in the last couple of years with previous teams, but it's a new team, new vision, new direction of where we want to go," said Sollman. "We have a lot of kids who are energized to start to build something."
Dallas kicks off the 2019-2020 season Wednesday at The Dalles before hosting Sisters Friday night (Picture By Jeremy McDonald)
Putting guys in the right place to succeed, and with the combination of how they face and get after it with that adversity on a game-by-game basis will dictate how far this team will go this season.
The challenge within the dynamic of the team this season will feature how Jace Grillo reacts to a new cast around him considering he is the lone Varsity returner. But Sollman likes the kids coming up behind him like a Jeremy Beall and the Senior Leadership from guys like Blaine Dunkin and Carson Overstreet entering this season.
"(Grillo), he's young still. Got time as a sophomore, but his adversity is going to be he's seen a Senior heavy group to guys who have barely touched a Varsity floor. It's going to be a different dynamic and see how he reacts to it," starts Sollman.
"We got Seniors who are born leaders and it's about taking those positive attributes and introducing to the kids and bringing it together to build a team. And what that team is going to look like and building that identity of what these kids want, what the program direction is going."
The journey starts Wednesday on the road at The Dalles at 6:30pm before hosting Sisters for their home opener Friday at 6:30pm.
5ADallas High SchoolHigh School Boys BasketballOSAA
Previous Post Young Bulldogs Season Starts Wednesday
Next Post Silverton's Defense Shuts Down Churchill In Opener


text:
Boffo Sales for Lambert's Debut
Despite AMA controversy, "For Your Entertainment" is a chart topper.
CNN | November 27, 2009 @ 10:14 AM	Last Updated: November 27, 2009 @ 10:22 AM
Adam Lambert's suggestive American Music Awards performance hasn't hurt sales of his first album.
With stiff competition from a slew of holiday compilations and Susan Boyle's first album, Lambert's debut is still managing to sell well online.
"For Your Entertainment," Lambert's first album after his run on "American Idol," where he came in second to winner Kris Allen, is the fifth most downloaded album on iTunes behind Lady Gaga, Susan Boyle, the "New Moon" soundtrack and John Mayer.
Lambert's 14-song album is also in the top 10 of Amazon.com music purchases as the ninth most purchased album.
Read more at CNN.


The Man-Machine Relation in Art and Science.
You are reading the word "now" right now. But what does that mean? What makes the ephemeral moment "now" so special? Its enigmatic character has bedeviled philosophers, priests, and modern-day physicists from Augustine to Einstein and beyond. Einstein showed that the flow of time is affected by both velocity and gravity, yet he despaired at his failure to explain the meaning of "now." Equally puzzling: why does time flow?


In a gradient light field the nanoparticles in the transparent medium are controlled by the electrostrictive forces, causing changes in their concentrations. The medium is characterized by a cubic nonlinearity in this case that is correct only for small intensities of radiation. For large radiation intensities the potential energy of particle is more than heat one and it requires consideration of non-linearity of the highest order. In this paper the theoretical analysis of the light induced mass transport in the dispersed liquid medium is carried out for large intensities of radiation, when the change in concentration is greater than or comparable to the primary. It is shown the recording of the grating is a non-linear process and the phase grating becomes non sinusoidal. The amplitudes of the first harmonics increases in this case with the intensity of the light at the non-linear regime making possible the significantly increasing of the efficiency of holograms recording. We define the thermal nonlinearity in transparent nanosuspension occurred due to the heat when an electrostrictive stream of particles flows in a viscous fluid.


text:
[TamilNet, Wednesday, 14 January 2015 09:48 No Comment]
Governments may come and go, but the State of Sri Lanka gets strengthened in its genocidal project whether there is war, peace or talk of 'change', comment the resettled women of Mu'raa-oadai village, situated 5 km south of Vaazhaich-cheanai town in Batticaloa district. 400 houses have been destroyed. Two temples are damaged. Almost all the resettled families are women-headed households, poorest of the poor. The women of the village say: "It is only when we have permanent security from future genocide, we can breath the air of freedom." The SL military has vacated last year from the village. But, a Buddhist statue and a 'sacred' Bo tree are still threatening the villagers who are haunted by the mere existence of the symbols of structural genocide.
Mu'raa-oadai was completely destroyed after facing a brutal onslaught of genocide between 1985 and 1995.
Following the Ceasefire agreement between the Colombo government and the Tamil Tigers in 2002, the village was secured back for civilian resettlement.
Even after the Eastern Province was fully seized by the SL military in 2007, the Sri Lankan State continued its genocidal occupation of the village till the last year.
400 houses and two Saiva temples have been destroyed.
The Sinhala military has exploited whatever remained in the village. Almost all the families are women-headed households.
"What we got during the past years for our so-called resettlement was only 12 sheets for roof and 8 bags of cement to the construction of our houses," A. Krishnamma, who lost her husband in the war told TamilNet.
The 'resettled' hut of Mrs Krishnammaa, who is a mother of two
Apart from the Buddhist temple and the Bo tree standing as the threatening symbols, the wild elephants brought from the jungles of South into the jungle in the Eastern province enter the village killing people, the villagers say.
"There is no potable water. There is no electricity. Dark jungle. But, it is our land. It was where my house was situated. So, I am staying here. We were living here for ages. It was here my mother was living. She was shot and killed by the Muslims. The Indian military that entered into our house shot and killed my husband. Later, we were displaced. For years we were living on the other side close to our village. I came back as I wanted to come to my house in my land. Karuna Ammaan [defected from the LTTE and became a paramilitary with a minister post in the SL government] came with a promise that he would give us a tube well. But, nothing of that sort happened," Krishnamma says.
"Before the destruction, we lived here without flooding. But, now we are also affected by flooding, as the Sri Lankan military which was stationed here had dug out sand from our lands. Most of the houses were heavily flooded. It never happened in this way before," she complained.
"It is said there is a new President elected with the promise of change. Will that happen?," she questioned.
"Our immediate need is potable water, electricity and resumption of livelihood. We will wait and see what happens," she added.
"We left behind all our goods at the house when we were chased out of our village. When lived here, there were five coconut trees. Now, everything is gone. The environment is gone. Our village has become a desert land."
As genocide and structural genocide are in the ideology of the State in Colombo and the Powers that back it, unless there are fundamental changes in people of the land having their State, the decades of the resettlement, rehabilitation experience of Eastern Eezham Tamils is not likely to change, commented social activists having long familiarity with the region.
The private land used by the SL military and abandoned last year has been fenced off by the owner of the property at Mu'raa-oadai
Australia in India: Rohit Sharma wicket leaves hosts on top - Australia hold the advantage after a rain-shortened second day of the decisive fourth Test against India in Brisbane.


Welcome to JDS Wealth Management Corp.
JDS Wealth Management Corp. is proud to serve the Lake Norman area as a retirement financial planning group with an emphasis in providing safe*, comprehensive investment strategies for a sound financial future. Our goal is to help you find the path to your successful retirement.
At JDS Wealth Management Corp. we will meet and work closely with you to evaluate your current financial health, set your retirement goals, strategize on how we can assist you in achieving your goals, and walk you through every step of the implementation process.
To schedule a time to discuss your retirement future, contact us at kelly@jdswealthmanagement.com or call us at (704) 660-0214.
All written content on this site is for information purposes only. Opinions expressed herein are solely those of JDS Wealth Management Corp., and our editorial staff. Material presented is believed to be from reliable sources, however, we make no representations as to its accuracy or completeness. All information and ideas should be discussed in detail with your individual adviser prior to implementation. Fee-only financial planning and investment advisory services are offered by JDS Wealth Management Corp, a Registered Investment Advisor in the State of North Carolina. The presense of this web site shall in no way be construed or interpreted as a solitation to sell or offer to sell investment advisory services to any residents of any State other than the State of North Carolina or where otherwise legally permitted. Insurance Products, services, and affiliations are offered through JDS Enterprizes, Inc.
*Any comments regarding safe and secure investments, and guaranteed income streams refer only to fixed insurance products. They do not refer, in any way, to securities or investment advisory products. Insurance and annuity product guarantees are subject to the claims paying ability of the issuing company.


22:06Joe Rogan DEYSTROYS Adam Conover in Trans-Children Hormone Debate!!Joe Rogan does a nice job defending children's rights against Adam Conover in JRE#1282.
9:03Child rights activist,Taiwo Akinlami speaks on tackling sexual abuseTVC Breakfast |18th April, 2019.


Two primes the difference between which is 2. Generalized twins are pairs of successive primes with difference $2m$, where $m$ is a given natural number. Examples of twins are readily found on consulting the table of prime numbers. Such are, e.g., 3 and 5, 5 and 7, 11 and 13, 17 and 19. Generalized twins — for $m=2$, for example — include 13 and 17, 19 and 23, 43 and 47. It is not yet (1992) known if the set of twins, and even the set of generalized twins for any given $m$, is infinite. This is the twin problem.
It is known that the infinite sum $\sum 1/p$ over all $p$ belonging to a twin is finite, see Brun sieve; Brun theorem. Its value has been estimated as $1.9021605831 \ldots$.
This page was last modified on 1 November 2014, at 19:52.


text:
Q: Visual Studio 2022 explanation to why searching Locals is incredibily slow and workaround NOTE: Visual Studio 2022 and not Visual Studio Code.
When debugging searching Locals using the search bar is incredibily slow (way more than 60 seconds for some searches). Even if I were to search a million lines with grep it would be instantaneous so somehow I must have misunderstood what operation the search bar in Locals actually does.

Is there any explanation as to why it is incredibily slow and how do I search for a variable name or value in my locals efficiently? (I want the search all my locals so changing Search Depth to a low number is not an alternative)
My Laptop details:
Windows 11 Pro
11th Gen Intel(R) Core(TM) i7-1185G7 @ 3.00GHz   1.80 GHz
32 GB Ram

redpajama_set_name: RedPajamaStackExchange


text:
/*used*/

package sample.physics;

import javafx.scene.shape.Shape;
import sample.model.Vector2D;

/**
 * @author Nils Wende
 * @author Simon Oswald
 * @author Jendrik Jordan
 */
class Collision {
	//checks if 2 JavaFX Shapes are colliding
	public boolean isColliding(Shape obj1, Shape obj2) {
		return Shape.intersect(obj1, obj2).getBoundsInLocal().getWidth() != -1;
	}
	//checks if the point y is above or below the window
	public boolean isOutsideVerticalBounds(double y, double height) {
		return ((y < 0) || (y > height));
	}
	//checks if the point x is left or right of the window
	public boolean isOutsideHorizontalBounds(double x, double width) {
		return ((x < 0) || (x > width));
	}
	//calculates the velocity after a collision
	public void getPostCollisionVelocity(Vector2D velocity, double dampening, Vector2D normalUnitVector) {
		final double factor = (1 + dampening) * velocity.scalarProduct(normalUnitVector);
		final Vector2D vec = normalUnitVector.scalarMultiplication(factor);
		velocity.subtract2(vec);
	}
}


text:
Premiere: Let It Breathe – "Greater Than I"
March 29, 2018 March 28, 2018 ninecirclesadmin
Let It Breathe – the aptly named slow-riding, fuzzed-out rockers from Minnesota – are quickly approaching the release of their self-titled debut album. While the April 27th official release date is still about a month away, Nine Circles is thrilled to whet your appetite with a new track titled "Greater Than I" RIGHT NOW.
While Let It Breathe is technically a debut, the gentlemen behind it are no strangers to each other nor the product they create. Randy Geraghty and Jason Knudson may have spent most of their time in the punk scene in 90s, but it was the arrival of Rob Rushing that allowed them to find their doomier sweet spot. Life may have eventually forced some distance between them, but this recent reunion shows no indication that these creative minds were ever apart. But don't take my word for it. Check out "Greater Than I" immediately below.
When looking at the history behind Let It Breathe, "Greater Than I" is a tremendous example of everything the band is capable of. While the overall sound is defined by the meandering grooves and fuzzed-out riffs we would expect, this track maintains an enjoyable, slightly upbeat cadence – almost as an homage to past punk influences. The tempo is enough to keep your foot-tapping while the track is still simultaneously successful in surrounding a listener with an overall smooth, spacey ambiance. Furthermore, it was Rushing's arrival from Arizona that first inspired this doomy shift. To that effect, the overall environment this song creates feels very much inspired by the desert. Both easy-going, yet heavy, with rugged open space and clear skies serving as the natural setting.
Let It Breathe
The combination of cadence, instrumental grit, and soaring vocals allow "Greater Than I" to cover a tremendous range and introduce us to a creative and well thought-out take on the stoner/fuzz spectrum. Regardless of how you want to categorize the Let It Breathe project, there is no doubt that this debut will bring a lot to the table. If this track is any indication, we have a lot to look forward to about one month from now.
As mentioned above, the official release date is April 27 on STB Records. Preorders for Let It Breathe are available here. For more information, be sure to follow Let It Breathe on Facebook.
Premieresdoom metal, greater than i, jason knudson, let it breathe, Premieres, randy geraghty, rob rushing, self titled, STB records, stoner metal
Previous Article Interview: Tony and John of Judicator on "The Last Emperor," Finding Light in the Trappings of History, and the State of Power Metal
Next Article Album Review: Lychgate – "The Contagion in Nine Steps"
One thought on "Premiere: Let It Breathe – "Greater Than I""
Pingback: Initial Descent: April 22 – 28, 2018 – Nine Circles


text:
Las elecciones al Parlamento escocés de 1999 se celebraron el 6 de mayo de 1999 y fueron las primeras votaciones tras el restablecimiento del Parlamento Escocés después de la Ley de Escocia de 1998. Tras las elecciones los partidos Laborista y Liberal-Demócrata formaron el primer ejecutivo nacional escocés que convirtió al laborista Donald Dewar en el primer encargado de ocupar el cargo de Primer Ministro de Escocia.

El Parlamento escocés se creó tras un referéndum sobre la devolución, celebrado el 11 de septiembre de 1997, en el que el 74,3% de los votantes aprobaron la idea de crear una cámara y un gobierno nacional escoceses. La Ley de Escocia fue aprobada por el Parlamento del Reino Unido, que estableció un Parlamento escocés y un Ejecutivo escocés.

El parlamento fue elegido utilizando la representación proporcional mixta, creando 73 circunscripciones electorales en donde el candidato más votado fue elegido como representante local. Los 73 diputados electos por voto directo se repartieron en ocho regiones que eligieron a siete miembros adicionales de forma proporcional a los resultados de cada región (56 en total) para llegar a la cifra de 129 escaños. Este sistema fue creado buscando que fuese improbable que cualquier partido obtuviera la mayoría absoluta en el nuevo parlamento, y por lo tanto los nuevos gobiernos deberían formarse en minoría o en coalición de varias fuerzas políticas.

Las primeras elecciones generales al parlamento escocés, tuvieron unos resultados previsibles respecto al ambiente político de la época, el Partido Laborista se mantenía con fuerza y popularidad después de lograr una victoria abrumadora en las elecciones generales del Reino Unido celebradas en 1997, de acuerdo a las predicciones fue el partido ganador al obtener 56 escaños, quedando a nueve de conseguir la mayoría absoluta.

El laborismo escocés formó un gobierno de coalición con los Liberal-Demócratas, que ganaron 17 escaños. Durante la campaña electoral, el Partido Nacional Escocés (SNP) tuvo un buen posicionamiento entre el electorado, consiguiendo hasta un 40% de aceptación, sin embargo, en las votaciones no se mostró lo ocurrido en los sondeos y los nacionalistas se quedaron por debajo de las estimaciones. El SNP fue el segundo partido más votado con 35 asientos, lo que representó su mejor resultado desde las elecciones británicas de octubre de 1974. Por su parte, el Partido Conservador aún no se recuperaba de la derrota obtenida dos años antes en las generales, por lo que no consiguió ningún diputado de forma directa, no obstante, sí que consiguió 18 representantes gracias a la representación proporcional. Por otro lado, dos partidos minoritarios, el Verde y el Socialista Escocés consiguieron un representante cada uno.

Se eligió además a un diputado independiente, Dennis Canavan, quien ganó el distrito electoral de Falkirk Oeste. Canavan contendió por su propia cuenta tras haber sido rechazado como candidato laborista.

Tras las elecciones, el nuevo Parlamento se reunió por primera vez el 12 de mayo en la Sala de la Asamblea General de la Iglesia de Escocia en Edimburgo, sin embargo, la transferencia de poderes desde Westminster al Parlamento escocés no tuvo lugar hasta la medianoche del 1 de julio, casi dos meses después de haberse conformado la primera legislatura de los nuevos poderes ejecutivo y legislativo de Escocia.

Resultados

Enlaces externos
 Scottish elections 1999 en BBC News (en inglés)

Escocia
1999
Escocia en 1999

redpajama_set_name: RedPajamaWikipedia