Stratford volleyball dominates Thorp in WIAA Division 3 regional semifinal

first_imgTigers advance to regional final Saturday night hosting AbbotsfordBy Paul LeckerSports ReporterSTRATFORD — The Stratford volleyball team is a win away from a regional title after a 3-0 sweep of Thorp in a WIAA Division 3 regional semifinal Thursday night at Stratford High School.The Tigers won the match 25-17, 25-14, 25-11 to advance to a regional final Saturday at home against Abbotsford. The match begins at 7 p.m.Stratford had its offense working on all cylinders against the Cardinals, belting 15 service aces and 41 kills in the victory.Mazie Nagel led Stratford with 13 kills and 11 digs, Makayla Krall added eight kills, eight aces and nine digs, Brooke Peterson had 21 assists, and Jadyn Dahlke had 19 assists for the Tigers.(Hub City Times Sports Reporter Paul Lecker is also the publisher of read more

How To Improve Test Coverage For Your Android App Using Mockito And Espresso

first_img Large previewUpon a click of the play button, the test version of the app will be installed on the emulator or device, and the test will run automatically on it. @Component.Builder interface Builder { fun appModule(appModule: AppModule): Builder fun build(): AppComponent } override fun onCreate(arguments: Bundle) { StrictMode.setThreadPolicy(StrictMode.ThreadPolicy.Builder().permitAll().build()) super.onCreate(arguments) } Large previewWriting Local Unit TestsUnit tests can be run locally on your development machine without a device or an emulator. This testing approach is efficient because it avoids the overhead of having to load the target app and unit test code onto a physical device or emulator every time your test is run. In addition to Mockito, you will also need to configure the testing dependencies for your project to use the standard APIs provided by the JUnit 4 framework.Setting Up The Development EnvironmentStart by adding a dependency on JUnit4 in your project. The dependency is of the type testImplementation, which means that the dependencies are only required to compile the test source of the project.testImplementation ‘junit:junit:4.12’We will also need the Mockito library to make interaction with Android dependencies easier.testImplementation “org.mockito:mockito-core:$MOCKITO_VERSION”Make sure to sync the project after adding the dependency. Android Studio should have created the folder structure for unit tests by default. If not, make sure the following directory structure exists:/app/src/test/java/com/maskaravivek/testingExamplesCreating Your First Unit TestSuppose you want to test the displayUserName function in the UserService. For the sake of simplicity, the function simply formats the input and returns it back. In a real-world application, it could make a network call to fetch the user profile and return the user’s name.@Singletonclass UserService @Injectconstructor(private var context: Context) { var button: Button? = null var userNameField: EditText? = null var displayUserName: TextView? = null override fun onCreate(savedInstanceState: Bundle?) { super.onCreate(savedInstanceState) AndroidInjection.inject(this) setContentView(R.layout.activity_main) initViews() } Related postsInclusive Components: Book Reviews And Accessibility Resources13th December 2019Should Your Portfolio Site Be A PWA?12th December 2019Building A CSS Layout: Live Stream With Rachel Andrew10th December 2019Struggling To Get A Handle On Traffic Surges10th December 2019How To Design Profitable Sales Funnels On Mobile6th December 2019How To Build A Real-Time Multiplayer Virtual Reality Game (Part 2)5th December 2019 @Module private inner class MockApplicationModule internal constructor(application: Application) : AppModule(application) { override fun provideUserService(context: Context): UserService { val mock = Mockito.mock( `when`(mock!!.displayUserName(“Test”)).thenReturn(“Hello Test!”) return mock } }}As you can see in the example above, we’ve used Mockito to mock UserService and assume the results. We still need a new runner that will point to the new application class with the overwritten data.class MockTestRunner : AndroidJUnitRunner() { How To Improve Test Coverage For Your Android App Using Mockito And Espresso How To Improve Test Coverage For Your Android App Using Mockito And Espresso Vivek Maskara 2018-07-25T14:00:04+02:00 2018-07-25T12:06:31+00:00In app development, a variety of use cases and interactions come up as one iterates the code. The app might need to fetch data from a server, interact with the device’s sensors, access local storage or render complex user interfaces.The important thing to consider while writing tests is the units of responsibility that emerge as you design the new feature. The unit test should cover all possible interactions with the unit, including standard interactions and exceptional scenarios.In this article, we will cover the fundamentals of testing and frameworks such as Mockito and Espresso, which developers can use to write unit tests. I will also briefly discuss how to write testable code. I’ll also explain how to get started with local and instrumented tests in Android.Recommended reading: How To Set Up An Automated Testing System Using Android Phones (A Case Study)Fundamentals Of TestingA typical unit test contains three phases.First, the unit test initializes a small piece of an application it wants to test.Then, it applies some stimulus to the system under test, usually by calling a method on it.Finally, it observes the resulting behavior.If the observed behavior is consistent with the expectations, the unit test passes; otherwise, it fails, indicating that there is a problem somewhere in the system under test. These three unit test phases are also known as arrange, act and assert, or simply AAA. The app should ideally include three categories of tests: small, medium and large.Small tests comprise unit tests that mock every major component and run quickly in isolation.Medium tests are integration tests that integrate several components and run on emulators or real devices.Large tests are integration and UI tests that run by completing a UI workflow and ensure that the key end-user tasks work as expected.Note: An instrumentation test is a type of integration test. These are tests that run on an Android device or emulator. These tests have access to instrumentation information, such as the context of the app under test. Use this approach to run unit tests that have Android dependencies that mock objects cannot easily satisfy.Nope, we can’t do any magic tricks, but we have articles, books and webinars featuring techniques we all can use to improve our work. Smashing Members get a seasoned selection of magic front-end tricks — e.g. live designing sessions and perf audits, too. Just sayin’! 😉 Explore Smashing Wizardry →Writing small tests allows you to address failures quickly, but it’s difficult to gain confidence that a passing test will allow your app to work. It’s important to have tests from all categories in the app, although the proportion of each category can vary from app to app. A good unit test should be easy to write, readable, reliable and fast.Here’s a brief introduction to Mockito and Espresso, which make testing Android apps easier.MockitoThere are various mocking frameworks, but the most popular of them all is Mockito:Mockito is a mocking framework that tastes really good. It lets you write beautiful tests with a clean & simple API. Mockito doesn’t give you hangover because the tests are very readable and they produce clean verification errors.Its fluent API separates pre-test preparation from post-test validation. Should the test fail, Mockito makes it clear to see where our expectations differ from reality! The library has everything you need to write complete tests.EspressoEspresso helps you write concise, beautiful and reliable Android UI tests.The code snippet below shows an example of an Espresso test. We will take up the same example later in this tutorial when we talk in detail about instrumentation tests.@Testpublic void setUserName() { onView(withId(“Vivek Maskara”)); onView(withId(; onView(withText(“Hello Vivek Maskara!”)).check(matches(isDisplayed()));}Espresso tests state expectations, interactions and assertions clearly, without the distraction of boilerplate content, custom infrastructure or messy implementation details getting in the way. Whenever your test invokes onView(), Espresso waits to perform the corresponding UI action or assertion until the synchronization conditions are met, meaning:the message queue is empty,no instances of AsyncTask are currently executing a task,the idling resources are idle.These checks ensure that the test results are reliable.Writing Testable CodeUnit testing Android apps is difficult and sometimes impossible. A good design, and only a good design, can make unit testing easier. Here are some of the concepts that are important for writing testable code.Avoid Mixing Object Graph Construction With Application LogicIn a test, you want to instantiate the class under test and apply some stimulus to the class and assert that the expected behavior was observed. Make sure that the class under test doesn’t instantiate other objects and that those objects do not instantiate more objects and so on. In order to have a testable code base, your application should have two kinds of classes:The factories, which are full of the “new” operators and which are responsible for building the object graph of your application;The application logic classes, which are devoid of the “new” operator and which are responsible for doing the work.Constructors Should Not Do Any WorkThe most common operation you will do in tests is the instantiation of object graphs. So, make it easy on yourself, and make the constructors do no work other than assigning all of the dependencies into the fields. Doing work in the constructor not only will affect the direct tests of the class, but will also affect related tests that try to instantiate your class indirectly.Avoid Static Methods Wherever PossibleThe key to testing is the presence of places where you can divert the normal execution flow. Seams are needed so that you can isolate the unit of test. If you build an application with nothing but static methods, you will have a procedural application. How much a static method will hurt from a testing point of view depends on where it is in your application call graph. A leaf method such as Math.abs() is not a problem because the execution call graph ends there. But if you pick a method in a core of your application logic, then everything behind the method will become hard to test, because there is no way to insert test doublesAvoid Mixing Of ConcernsA class should be responsible for dealing with just one entity. Inside a class, a method should be responsible for doing just one thing. For example, BusinessService should be responsible just for talking to a Business and not BusinessReceipts. Moreover, a method in BusinessService could be getBusinessProfile, but a method such as createAndGetBusinessProfile would not be ideal for testing. SOLID design principles must be followed for good design:S: single-responsibility principle;O: open-closed principle;L: Liskov substitution principle;I: interface segregation principle;D: dependency inversion principle.In the next few sections, we will be using examples from a really simple application that I built for this tutorial. The app has an EditText that takes a user name as input and displays the name in a TextView upon the click of a button. Feel free to take the complete source code for the project from GitHub. Here’s a screenshot of the app: override fun onCreate(savedInstanceState: Bundle?) { super.onCreate(savedInstanceState) AndroidInjection.inject(this) setContentView(R.layout.activity_main) initViews() } @Mock internal var context: Context? = null @InjectMocks internal var userService: UserService? = null @Before fun setup() { MockitoAnnotations.initMocks(this) }}Now you are done setting up your test class. Let’s add a test to this class that verifies the functionality of the displayUserName function. Here’s what the test looks like:@Testfun displayUserName() { doReturn(“Hello %s!”).`when`(context)!!.getString(any( val displayUserName = userService!!.displayUserName(“Test”) assertEquals(displayUserName, “Hello Test!”)}The test uses a doReturn().when() statement to provide a response when a context.getString() is invoked. For any input integer, it will return the same result, “Hello %s!”. We could have been more specific by making it return this response only for a particular string resource ID, but for the sake of simplicity, we are returning the same response to any input.Finally, here’s what the test class looks like:class UserServiceTest { @Mock internal var context: Context? = null @InjectMocks internal var userService: UserService? = null @Before fun setup() { MockitoAnnotations.initMocks(this) } this.button!!.setOnClickListener({ displayUserName!!.text = “Hello ${userNameField!!.text}!” }) }}To create a test for the MainActivity, we will start by creating a MainActivityTest class under the androidTest directory. Add the AndroidJUnit4 annotation to the class to indicate that the tests in this class will use the default Android test runner class.@RunWith(AndroidJUnit4::class)class MainActivityTest {}Next, add an ActivityTestRule to the class. This rule provides functional testing of a single activity. For the duration of the test, you will be able to manipulate your activity directly using the reference obtained from getActivity().@Rule @JvmField var activityActivityTestRule = ActivityTestRule( that you are done setting up the test class, let’s add a test that verifies that the user name is displayed by clicking the “Set User Name” button.@Testfun setUserName() { onView(withId(“Vivek Maskara”)) onView(withId( onView(withText(“Hello Vivek Maskara!”)).check(matches(isDisplayed()))}The test above is quite simple to follow. It first simulates some text being typed in the EditText, performs the click action on the button, and then checks whether the correct text is displayed in the TextView.The final test class looks like this:@RunWith(AndroidJUnit4::class)class MainActivityTest { @Inject lateinit var userService: UserService @Test fun setUserName() { onView(withId(“Test”)) onView(withId( onView(withText(“Hello Test!”)).check(matches(isDisplayed())) }}The test will run successfully when you click on the green play button in the IDE. fun displayUserName(name: String): String { val userNameFormat = context.getString(R.string.display_user_name) return String.format(Locale.ENGLISH, userNameFormat, name) }}We will start by creating a UserServiceTest class in our test directory. The UserService class uses Context, which needs to be mocked for the purpose of testing. Mockito provides a @Mock notation for mocking objects, which can be used as follows:@Mock internal var context: Context? = nullSimilarly, you’ll need to mock all dependencies required to construct the instance of the UserService class. Before your test, you’ll need to initialize these mocks and inject them into the UserService class.@InjectMock creates an instance of the class and injects the mocks that are marked with the annotations @Mock into it.MockitoAnnotations.initMocks(this); initializes those fields annotated with Mockito annotations.Here’s how it can be done:class UserServiceTest { open fun initAppComponent(): AppComponent { return DaggerAppComponent .builder() .appModule(AppModule(this)) .build() } @Provides @Singleton internal open fun provideUserService(context: Context): UserService { return UserService(context) }}The AppComponent class lets you build the object graph for the application.@Singleton@Component(modules = [(AndroidSupportInjectionModule::class), (AppModule::class), (ActivityBuilder::class)])interface AppComponent { Large previewIntrumentation Testing Using Dagger, Mockito, And EspressoEspresso is one of the most popular UI testing frameworks, with good documentation and community support. Mockito ensures that objects perform the actions that are expected of them. Mockito also works well with dependency-injection libraries such as Dagger. Mocking the dependencies allows us to test a scenario in isolation.Until now, our MainActivity hasn’t used any dependency injection, and, as a result, we were able to write our UI test very easily. To make things a bit more interesting, let’s inject UserService in the MainActivity and use it to get the text to be displayed.class MainActivity : AppCompatActivity() { HomeWeb DesignHow To Improve Test Coverage For Your Android App Using Mockito And Espressocenter_img private fun initViews() { button = this.findViewById( userNameField = this.findViewById( displayUserName = this.findViewById( @Test fun setUserName() { onView(withId(“Vivek Maskara”)) onView(withId( onView(withText(“Hello Vivek Maskara!”)).check(matches(isDisplayed())) }}Running Your Instrumentation TestsJust like for unit tests, click on the green play button in the IDE to run the test. override fun activityInjector(): DispatchingAndroidInjector? { return dispatchingActivityInjector }}Setting Up Dagger In The Test ApplicationIn order to mock responses from the server, we need to create a new Application class that extends the class above.class TestExamplesApplication : ExamplesApplication() { fun inject(application: ExamplesApplication)}Create a method that returns the already built component, and then inject this component into onCreate().open class ExamplesApplication : Application(), HasActivityInjector { @Inject lateinit var dispatchingActivityInjector: DispatchingAndroidInjector @Throws(InstantiationException::class, IllegalAccessException::class, ClassNotFoundException::class) override fun newApplication(cl: ClassLoader, className: String, context: Context): Application { return super.newApplication(cl,, context) }}Next, you need to update the build.gradle file to use the { … override fun onCreate() { super.onCreate() initAppComponent().inject(this) } private fun initViews() { button = this.findViewById( userNameField = this.findViewById( displayUserName = this.findViewById( @Test fun displayUserName() { doReturn(“Hello %s!”).`when`(context)!!.getString(any( val displayUserName = userService!!.displayUserName(“Test”) assertEquals(displayUserName, “Hello Test!”) }}Running Your Unit TestsIn order to run the unit tests, you need to make sure that Gradle is synchronized. In order to run a test, click on the green play icon in the IDE. override fun initAppComponent(): AppComponent { return DaggerAppComponent.builder() .appModule(MockApplicationModule(this)) .build() } var button: Button? = null var userNameField: EditText? = null var displayUserName: TextView? = null How To Improve Test Coverage For Your Android App Using Mockito And EspressoYou are here: @Rule @JvmField var activityActivityTestRule = ActivityTestRule( defaultConfig { … testInstrumentationRunner “.MockTestRunner” }}Running The TestAll tests with the new TestExamplesApplication and MockTestRunner should be added at androidTest package. This implementation makes the tests fully independent from the server and gives us the ability to manipulate responses.With the setup above in place, our test class won’t change at all. When the test is run, the app will use TestExamplesApplication instead of ExamplesApplication, and, thus, a mocked instance of UserService will be used.@RunWith(AndroidJUnit4::class)class MainActivityTest { @Rule @JvmField var activityActivityTestRule = ActivityTestRule( this.button!!.setOnClickListener({ displayUserName!!.text = userService.displayUserName(userNameField!!.text.toString()) }) }}With Dagger in the picture, we will have to set up a few things before we write instrumentation tests.Imagine that the displayUserName function internally uses some API to fetch the details of the user. There should not be a situation in which a test does not pass due to a server fault. To avoid such a situation, we can use the dependency-injection framework Dagger and, for networking, Retrofit.Setting Up Dagger In The ApplicationWe will quickly set up the basic modules and components required for Dagger. If you are notfamiliar with Dagger, check out Google’s documentation on it. We will start adding dependencies for using Dagger in the build.gradle file.implementation “$DAGGER_VERSION”implementation “$DAGGER_VERSION”implementation “$DAGGER_VERSION”kapt “$DAGGER_VERSION”kapt “$DAGGER_VERSION”Create a component in the Application class, and add the necessary modules that will be used in our project. We need to inject dependencies in the MainActivity of our app. We will add a @Module for injecting in the activity.@Moduleabstract class ActivityBuilder { @ContributesAndroidInjector internal abstract fun bindMainActivity(): MainActivity}The AppModule class will provide the various dependencies required by the application. For our example, it will just provide an instance of Context and UserService.@Moduleopen class AppModule(val application: Application) { @Provides @Singleton internal open fun provideContext(): Context { return application } Large previewThat’s it! You have successfully set up Dagger and run tests using Espresso and Mockito.ConclusionWe’ve highlighted that the most important aspect of improving code coverage is to write testable code. Frameworks such as Espresso and Mockito provide easy-to-use APIs that make writing tests for various scenarios easier. Tests should be run in isolation, and mocking the dependencies gives us an opportunity to ensure that objects perform the actions that are expected of them.A variety of Android testing tools are available, and, as the ecosystem matures, the process of setting up a testable environment and writing tests will become easier.Writing unit tests requires some discipline, concentration and extra effort. By creating and running unit tests against your code, you can easily verify that the logic of individual units is correct. Running unit tests after every build helps you to quickly catch and fix software regressions introduced by code changes to your app. Google’s testing blog discusses the advantages of unit testing.The complete source code for the examples used in this article is available on GitHub. Feel free to take a look at it. (da, lf, ra, al, il)From our sponsors: How To Improve Test Coverage For Your Android App Using Mockito And Espresso Posted on 25th July 2018Web Design FacebookshareTwittertweetGoogle+share making sure that Gradle is synchronizedWhen the unit tests are run, successfully or otherwise, you should see this in the “Run” menu at the bottom of the screen:Large previewYou are done with your first unit test!Writing Instrumentation TestsInstrumentation tests are most suited for checking values of UI components when an activity is run. For instance, in the example above, we want to make sure that the TextView shows the correct user name after the Button is clicked. They run on physical devices and emulators and can take advantage of the Android framework APIs and supporting APIs, such as the Android Testing Support Library.We’ll use Espresso to take actions on the main thread, such as button clicks and text changes.Setting Up The Development EnvironmentAdd a dependency on Espresso:androidTestImplementation ‘’Instrumentation tests are created in an androidTest folder./app/src/androidTest/java/com/maskaravivek/testingExamplesIf you want to test a simple activity, create your test class in the same package as your activity.Creating Your First Instrumentation TestLet’s start by creating a simple activity that takes a name as input and, on the click of a button, displays the user name. The code for the activity above is quite simple:class MainActivity : AppCompatActivity() {last_img read more

Council approves road project at Providence and Broadway

first_imgYou will see a lot of construction on the southeast corner of the Broadway and Providence intersection next spring.The Columbia City Council approved some downtown changes on Monday night. The city will extend the right turn lane from Providence to Broadway, and make sidewalk improvements.Dave Nichols with Public Works says it will have more space for people to make that turn.“It allows, as the car is approaching if it’s in that dedicated lane, to be able to then get into the intersection and have a better visibility of the crosswalk area,” Nichols says. “Helps traffic flow considerably through this intersection.”The $130,000 project is part of the planned Flat Branch Park expansion. That is in the area where CVS Pharmacy tried to build several times, but was rejected.“This is also forward-looking,” Mayor Brian Treece says. “We don’t want to make big improvements to that city-owned property there, only to extend that lane in the future.”last_img read more

Santon adds to Roma injury crisis?

first_img Watch Serie A live in the UK on Premier Sports for just £11.99 per month including live LaLiga, Eredivisie, Scottish Cup Football and more. Visit: Davide Santon could have added to Roma’s injury crisis after the defender trained apart from the squad with the flu. Roma already have seven players out, but that risks becoming eight if Santon does not recover by the time they release their squad list for tomorrow’s Europa League match with Borussia Monchengladbach. Elsewhere, Cengiz Under and Henrikh Mkhitaryan continued to work away from the first team and Corriere dello Sport also considers them doubtful to face Milan this weekend. Every precaution is still being taken with Edin Dzeko, who trained on Wednesday with a protective mask.last_img read more

10 months agoYoung blasts claims Man Utd players celebrated Mourinho sack

first_imgYoung blasts claims Man Utd players celebrated Mourinho sackby Paul Vegas10 months agoSend to a friendShare the loveManchester United captain Ashley Young denies the players were celebrating the sacking of Jose Mourinho last week.United responded to the appointment of caretaker manager Ole Gunnar Solskjaer with a 5-1 win at Cardiff City.Several reports indicated that United’s stars were happy with the decision, with some citing that they had even celebrated the news. However, Young firmly shut those claims down.”No celebration at all. Absolute lies,” the full-back said.”Obviously it was disappointing for the manager to get sacked. In his two-and-a-half years, he won trophies.”We have to take some responsibility for that [his sacking] as we are on the pitch.”Like I said. we have to move on from that. Ole [Gunnar Solksjaer] has come in and we were preparing in the right way for a game even though it’s been a crazy week, but as professional players we have to get on with the job in hand and that is what we did today.” About the authorPaul VegasShare the loveHave your saylast_img read more

10 months agoMan City management make January market decision

first_imgMan City management make January market decisionby Paul Vegas10 months agoSend to a friendShare the loveManchester City are willing to go through January without adding to Pep Guardiola’s squad.Last season’s champions City have fallen behind the Reds in this season’s title race after losing two games on the bounce against Crystal Palace and Leicester City respectively.But The Times says City have no plans to enter the transfer market when it opens next week.Both Guardiola and the Citizens board believe they can catch Liverpool and retain their Premier League crown. TagsTransfersAbout the authorPaul VegasShare the loveHave your saylast_img read more

We Talk Curling And Stats With The Guys Who Won The Gold

Embed Code It all started as a predawn tweet: More: Apple Podcasts | ESPN App | RSS | Embed But after the U.S. men’s Olympic curling team won gold in Pyeongchang, we knew it had to become reality. So, on Friday, despite bad weather in the Northeast — which left Nate calling in from an airport tarmac after his flight was diverted — I was joined in the FiveThirtyEight podcast studio by Olympic champion curlers John Shuster, Tyler George and Matt Hamilton.We talked about curling analytics, the team’s new celebrity fans and where the sport goes from here. You can listen to it on your phone by subscribing to our NBA podcast, “The Lab,”1Sadly, we don’t have a curling podcast feed … yet. or by clicking the play button below. By Neil Paine Here are some excerpts from the conversation.On advice for first-time curlers:Hamilton: “My best advice would be, don’t fall. In my first game at the Olympics, I fell. So don’t go down — it’s still hard ice. But in seriousness, if you go in with an open mind and are really curious about the sport itself — not just the throwing aspects, but actually immersing yourself in what curling is about — you’ll find all these people who are so willing to help and teach and get you into the strategy, which is really the draw. … Making shots is great, and it felt good when you made your first couple of shots in curling when you tried it, but when you finally learn why you’re throwing that shot, why making that shot set you up later in the game to win, it’s just a remarkable feeling. It really is like chess on ice, just that mental game mixed with a finesse game, mixed with the brute force of sweeping. It has all the aspects of a really fun game.”On preparing with analytics guru Gerry Geurts of “He sat us down at our summer camp and explained to us where we sat [among] elite players at certain things, like with the hammer/without the hammer, up by one with the hammer/down by one with the hammer … and it went on for all of the potential scoring scenarios. And he gave us feedback [on] which positions we could be better at, which ones we’re really good at, where we need to keep doing what we’re doing. Then he gave us some info on other teams in those same kind of numbers. … I’d be lying if I said that didn’t come into play at all.”On the flaws of using curling percentage to judge players and teams:George: “It’s incredibly subjective because it depends on what types of shots you’re playing. And the way that they do stats for the television events [is] really simplistic because they’re only going on make/miss or how close you were to making the shot [but] not factoring in the difficulty of the shot. … So for the viewer at home, looking at our percentages, they probably thought that we weren’t playing nearly as well as our record would imply. … But a lot of that is because we’re playing with a lot more rocks in play. We’re making a lot more difficult shots, but the viewers are not seeing that.”On the role analytics might have in the game in the future:George: “There’s a major change coming up next season where they’re literally changing the rules in the game, where stats are going to have to be applied to figure out what the best strategies are … (Editor’s note: The change involves being able to add one extra protected stone to the area in front of the house.) It doesn’t seem like much — it’s only one more rock that you can’t take out to play — but it completely changes the strategy of how you start ends out, and they’ve been using it in Grand Slam events so far. So you see it maybe six or seven times a year, and teams are still kind of tinkering with strategy on how to defend, especially [because] it’s a way more offensive game. … Stats are going to be huge in figuring out the best ways to go about defending with this new strategy because we just haven’t done it that much.”On whether curling will be able to capitalize on its newfound popularity:Shuster: “I think you’re going to see it because [of] the ratings that we were getting during the Olympics and the ratings we’ve been getting with “Curling Night in America” the last couple of years. What happens is, we haven’t had national television coverage between Olympic cycles, and then every Olympics we get more and more coverage and the ratings get better and better. And then all of a sudden, NBC Sports Network ran “Curling Night in America,” so we had a weekly show going on. After we won the gold, they’re going to show one live game every single day during the world [championships] that are coming up in Vegas. … I think curling right now could be on [the same] trajectory as something like poker was 10 years ago. If the world championships are high-quality, entertaining TV this year, people are going to demand it more, and we’re going to start seeing it on more of a regular basis moving forward.” read more

30 NFL teams survey Buckeye prospects at Pro Day

Ohio State football players showed their talents for 30 different NFL teams at the Buckeyes’ Pro Day in the Woody Hayes Athletic Center Friday. Thirteen players, including running back Daniel “Boom” Herron, wide receiver DeVier Posey, offensive tackles Mike Adams and J.B. Shugarts, linebacker Andrew Sweat and center Mike Brewster, attended the workout. Scouts from every NFL team except the Chicago Bears and New York Jets came to take in the action and evaluate the NFL hopefuls. Herron compared the day to a job interview. “(There were) a lot of great coaches out here,” Herron said. “You just want to put on the best show, be at your best.” The Buckeyes’ Pro Day, which was led by OSU football strength and conditioning coach Mickey Marotti, schedule featured events such as the 40-yard dash, 20-yard shuttle, three cone drill, broad jump and individual position drills. The 40-yard dash, which is considered by many as one of the most important measurable heading into the NFL Draft in April, saw only 10 Buckeyes and three non-OSU participants participate in the drill as Posey, Adams and Brewster opted to not test their 40-times. Posey said the day’s events were the best part of the drafting process. “This is the best part, man. Just football,” Posey said. “Running routes, catching balls, I feel like I do that the best. I just wanted to come out and make sure I catch everything today.” Shugarts said he met with several teams, including the Kansas City Chiefs. “I was doing a lot of board work with the Chiefs,” Shugarts said. “I just got done with that … Just going over pass protections, they asked us our favorite run plays.” While the purpose of the day was for Buckeye football players to prove to NFL scouts they have the ability to play at the next level, players’ family, friends and a number of former OSU players showed up to watch the action for themselves. Notably, former Buckeye football players Beanie Wells, Jim Cordle, Doug Worthington, Bobby Carpenter, Joey Galloway, LeCharles Bentley, Chris Spielman, Andy Katzenmoyer and Dick LeBeau attended. Additionally, current OSU football players such as Braxton Miller, Etienne Sabino, Travis Howard and Bradley Roby also came to support their former teammates. Other players who took part in the day’s trials were Dionte Allen, Nate Ebner, Donnie Evege, Aaron Gant and Grant Schwartz. In some ways, Friday’s combine was one of the last chances for OSU players to improve their NFL Draft status in the eyes of teams around the league. Officially, the draft opens on April 26. Andrew Hollern contributed to this story. read more

Kevin De Bruyne returns to training at Man City

first_imgManchester City have received a welcome boost by the return of Kevin De Bruyne after a seven-week absenceThe Belgian playmaker sustained a knee injury in a training session just days after City’s opening day 2-0 win away to Arsenal in August, which ruled him out for the next three months.But, following manager Pep Guardiola’s comments that De Bruyne could return to training this week, City have now confirmed the news.The 27-year-old joined the rest of the first-team for a morning training session as City prepare for their Champions League trip to Hoffenheim on Tuesday.No timetable for De Bruyne’s return to competitive action has been released yet by City, although it’s understood that the player himself is planning on coming back for the Manchester derby on November 11.Premier LeaguePremier League Betting: Match-day 5 Stuart Heath – September 14, 2019 Going into the Premier League’s match-day five with a gap already beginning to form at the top of the league. We will take a…Despite a foot injury, Sergio Aguero was also in attendance during the training session as City hope to bounce back from their Group F opening defeat to Lyon last month.Back in training! 💪🏼— Kevin De Bruyne (@DeBruyneKev) October 1, 2018last_img read more

Milcon Spending Bill includes Missile Site BRAC Amendments

first_imgHouse lawmakers approved two amendments of interest to defense communities — one that would provide funding for an East Coast missile defense site and one that would prohibit a new BRAC round — as part of the fiscal 2016 Military Construction-Veterans Affairs spending bill the chamber approved Thursday.  Language allocating $30 million for the planning, design and construction of an East Coast missile defense site was offered by freshman Rep. Elise Stefanik (R-N.Y), whose district includes Fort Drum.Last year, the Defense Department said it would prepare environmental impact statements at four locations, including Fort Drum, N.Y., to determine a potential site to host ground-based interceptors to protect the East Coast. The department’s effort to identify an East Coast missile defense site follows Congress’ direction to study at least three potential sites, including at least two on the East Coast. DOD, however, has made no decision to proceed with construction of a new missile defense site, and officials do not believe it is necessary.The other three sites the department is studying are: Naval Air Station Portsmouth SERE Training Area, Maine; Camp Ravenna Joint Training Center, Ohio; and Fort Custer Training Center, Mich.Lawmakers also approved by voice vote an amendment that would prohibit the use of funds from the milcon spending bill to implement a new BRAC round. The provision was introduced by another Republican freshman, Rep. John Ratcliffe (Texas). Dan Cohen AUTHORlast_img read more