f2e | teach | Learning library

You'll need to import selenium module to run this. Also you need to have the chromedriver in your path. Maybe you already do since you mentioned web scraping.

EDIT: the code now doesn't show the GUI and downloads the file to the same folder of the py script.

I've done some experiments using LIKWID, which is similar to PAPI, on Haswell. I found out that the calls to the functions that initialize and read the performance counters can cause more than 600 replacements in the L1 cache. Since the L1 cache has only 512 lines, this means that these functions may evict many of the lines that you would otherwise expect to be in the L1. By looking at the relatively large source code of PAPI_start_counters and _internal_hl_read_cnts, it seems to me that these functions may evict many lines from the L1, so the array elements don't survive in the L1 across these calls. I've verified this by using loads instead of stores and counting hits and misses using MEM_LOAD_RETIRED.*. I think the solution would be to use the RDPMC instruction. I have not used this instruction directly before. The code snippets here look useful.

Alternatively, you can put two copies of the loop after PAPI_start_counters/PAPI_read_counters and then subtract from the results the counts for one copy of the loop. This method works well.

By the way, the L1D.REPLACEMENT counter seems to be fairly accurate on Haswell when the number of cache lines accessed is about larger than 10. Perhaps the count would be exact by using RDPMC.

From your previous question, it seems that you're on Skylake. According to the PAPI event mapping, PAPI_L1_DCM and PAPI_L2_TCM are mapped to L1D.REPLACEMENT and LONGEST_LAT_CACHE.REFERENCE performance monitoring events on Intel processors. These are defined in the Intel manual as follows:

L1D.REPLACEMENT: Counts L1D data line replacements including opportunistic replacements, and replacements that require stall-for-replace or block-for-replace.

LONGEST_LAT_CACHE.REFERENCE: This event counts core-originated cacheable demand requests that refer to the last level cache (LLC). Demand requests include loads, RFOs, and hardware prefetches from L1D, and instruction fetches from IFU.

Without getting into the details of when these events exactly occur, there are three important points here that are relevant to your question:

• Both events are counted at the cache-line granularity, not x86 instruction or load uop granularities.
• These events may occur due to the L1D hardware prefetchers. This can impact miss2.
• There is no way to count L1D hits at the cache line granularity for a specific physical or logical core using these events (or any other set of events on SnB-based micoarchitectures).

On Skylake, there are other native events that you can use to count L1D misses and hits per load instruction. You can use MEM_LOAD_RETIRED.L1_HIT to count the number of retired load instructions that hit in the L1D. You can use MEM_INST_RETIRED.ALL_LOADS-MEM_LOAD_RETIRED.L1_HIT to count the number of retired load instructions that miss in the L1D. There doesn't seem to be PAPI events for them. According to the documentation, you can pass native event codes to PAPIF_start_counters.

Another issue is that it's not clear to me whether PAPIF_start_counters by default will count only user events of both kernel and user events. It seems that you can use PAPI_create_eventset to control the counting domain.

The calls to PAPI APIs can also impact the event counts. You can try to measure this using an empty block as follows:

There's a bit of confusion here. The command you used does not merge development into your branch. Recall that git pull combines git fetch and git merge. The argument development:yinronghui-shopcollect-20170822 is what's called a refspec. It tells git fetch which branches to fetch and where to store them.

Normal fetching stores the remote branches locally in a special namespace, so that you can compare your local branches to them, merge them, etc. You can see the fetched branches using git remote -r. A branch development fetched from origin usually shows up as origin/development.

Your git pull tells fetch to not use that special namespace but instead try to overwrite your branch directly, without merging, which would make any unpushed commits on your branch disappear and cause all kinds of other confusion. Git realizes that you probably didn't want to do that, and gives you an error to be safe.

The standard way to do this is to do this as a local operation.

1. Make sure your local development is up-to-date (optional, you can merge only what you've got if you like).
2. Checkout your branch.
3. Merge development locally: git merge development

You are almost there :-)

How about using pandas to create a dataframe first then save it, something like this "continuing from your code":

It is not possible to execute a jar embedded in a jar like that, but even if it were possible, your Java command line is simply incorrect. That is because the -ifExists (and the other options) are interpreted as commandline options of the java executable.

You will get the same error message if you extract that h2-1.3.161.jar from the f2e-test-framework-1.8.3-SNAPSHOT.jar and tried to execute it with the same command line.

It would either need to use -jar instead of -cp, or you would need to specify the class to run before -ifExists.

Is the file a .class file? Can you open the file in your test? Can you instantiate a class from that jar file?

To get to the location of a class you can use the following method: System.out.println(this.getClass().getProtectionDomain().getCodeSource().getLocation().toURI().getPath());

And I'm one of those too who chose scalatest over cucumber, cucumber was too much for me(ME) to write the feature file, and then come back to scala/java file and change accordingly. Maintain two files. I actually played cucumber java, scala cucumber might be more fluent. Anyway, I am liking scalatest so far for all my unit testing, component testing and the flow testing.

In case like yours if the properties are common for multiple scenarios and you won't mutate inside scenarios then defining as common property would be fine, as below.

See about DB init here

In fact you need to add to your spring something like this